home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / Drtf / DRichViewNu.cpp < prev    next >
Text File  |  1996-07-05  |  93KB  |  3,476 lines
  1. // DRichView.cpp
  2. // d.g.gilbert
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DWindow.h"
  7. #include "DPanel.h"
  8. #include "DControl.h"
  9. #include "DFile.h"
  10. #include "DFindDlog.h"
  11. #include "DList.h"
  12. #include "DUtil.h"
  13. #include "DDialogText.h"
  14. #include "DViewCentral.h"
  15.  
  16. #include "DDrawPICT.h"
  17.  
  18. #include "DRichStyle.h"
  19. #include "DRichMoreStyle.h"
  20. #include "DRichViewNu.h"
  21. #include "DRTFHandler.h"
  22. #include "DPICTHandler.h"
  23. #include "DHTMLHandler.h"
  24. #include "DGIFHandler.h"
  25.  
  26. #include "DIconLib.h"
  27. #include "DIcons.h"
  28.  
  29.  
  30. extern DDrawPict* gDrawPict; 
  31.  
  32. static Boolean gNotInitted = true;
  33.  
  34. #ifdef DBUG
  35. #define Debug(x)  fprintf(stderr,x)
  36. #define Debug1(x,y)  fprintf(stderr,x,y);
  37. #else
  38. #define Debug(x) 
  39. #define Debug1(x,y)
  40. #endif
  41.  
  42. enum {
  43.     chPictTag = 26,
  44.     MAXFONTS  = 32
  45.     };
  46.  
  47. static struct fontheights {
  48.   Nlm_FonT  font;
  49.   short          height;
  50.     } gFontHeights[MAXFONTS];
  51.  
  52. extern "C" Nlm_Boolean Nlm_DoClick (Nlm_GraphiC a, Nlm_PoinT pt); // vibutils.c
  53.  
  54. //short DRichView::GetFontHeight(Nlm_FonT font)
  55. static short GetFontHeight(Nlm_FonT font)
  56. {
  57.             // Returns the pixel height of a font, caching for quicker access
  58.   short  height, i;
  59.   height = 0;
  60.   i = 0;
  61.   while (i < MAXFONTS && gFontHeights[i].font != font
  62.          && gFontHeights[i].font != NULL)
  63.             i++;
  64.   if (gFontHeights[i].font == font) 
  65.     return gFontHeights[i].height;
  66.     else {
  67.     Nlm_SelectFont(font);
  68.     height = Nlm_LineHeight();
  69.     if (i < MAXFONTS) {
  70.       gFontHeights[i].font = font;
  71.       gFontHeights[i].height = height;
  72.         }
  73.        return height;
  74.         }
  75. }
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82. //class DRichView : public DPanel
  83.  
  84.  
  85. extern "C" void richPanelClickProc(Nlm_PaneL item, Nlm_PoinT mouse)
  86. {
  87.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  88.     if (obj) obj->Click(mouse);
  89. }
  90.  
  91. extern "C" void richPanelDragProc(Nlm_PaneL item, Nlm_PoinT mouse)
  92. {
  93.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  94.     if (obj) obj->Drag(mouse);
  95. }
  96.  
  97. extern "C" void richPanelHoldProc(Nlm_PaneL item, Nlm_PoinT mouse)
  98. {
  99.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  100.     if (obj) obj->Hold(mouse);
  101. }
  102.  
  103. extern "C" void richPanelReleaseProc(Nlm_PaneL item, Nlm_PoinT mouse)
  104. {
  105.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  106.     if (obj) obj->Release(mouse);
  107. }
  108.  
  109. extern "C" void richPanelDrawProc(Nlm_PaneL item)
  110. {
  111.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  112.     if (obj) obj->Draw();
  113. }
  114.  
  115. extern "C" void richPanelScrollProc(Nlm_BaR sb, Nlm_SlatE slate, short newval, short oldval)
  116. {
  117.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)slate);
  118.     if (obj) obj->ScrollDoc(sb, newval, oldval);
  119.     //if (obj) obj->Scroll(true, obj, newval, oldval);
  120. }
  121.  
  122. extern "C" void richPanelResetProc(Nlm_PaneL item)
  123. {
  124.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  125.         // damn, this is called by Vibrant cleaner-upper AFTER DRichView::~DRichView() !!
  126.     if (obj) obj->ResetDoc();
  127. }
  128.  
  129.  
  130. //typedef    short (*CompareFunc)( void*, void*);     // compare two list/array Items 
  131.  
  132. short richPanelCompareStyles( void* item1, void* item2)
  133. {
  134. #if 0
  135.     if ( ((DRichStyle*) item1)->IsNotEqual( (DRichStyle*) item2) ) { 
  136.         if (item1 > item2) return 1;
  137.         else return -1;
  138.         }
  139.     else 
  140.         return 0;
  141. #else
  142.     return MemCmp( item1, item2, sizeof(DRichStyle));
  143. #endif
  144. } 
  145.  
  146.  
  147.  
  148. DRichView::DRichView(long id, DView* itsSuperior, short pixwidth, short pixheight,
  149.             Boolean hasVscroll):
  150.     DPanel(id, itsSuperior, pixwidth, pixheight, DPanel::subclasscreates)
  151. {
  152.      Nlm_SltScrlProc scrollproc;
  153.      fNumItems= 0;
  154.     fNumLines= 0;
  155.     fBarmax= 0;
  156.     fDocFormat= 0;
  157.     fTabCount= 1;
  158.   fAutoAdjust= true; 
  159.   fIsVirtual= false; 
  160.   fDodraw= true;
  161.     fStyles= NULL; 
  162.     fParags= NULL; 
  163.     fCurrentStyle= NULL;
  164.     fSelParag= fSelChar= fSelEndParag= fSelEndChar= 0;
  165.     fSelected= fSelInPict= false;
  166.     ZeroCharWidths();
  167.  
  168. #if 0    
  169.     if (!Nlm_EmptyRect( &DRichTextDoc::gRichDocRect)) {
  170.         pixwidth= DRichTextDoc::gRichDocRect.right - DRichTextDoc::gRichDocRect.left;
  171.         pixheight= DRichTextDoc::gRichDocRect.bottom - DRichTextDoc::gRichDocRect.top;
  172.         }
  173. #endif        
  174.     if (pixwidth ==0) pixwidth = Nlm_screenRect.right - Nlm_screenRect.left - 60;
  175.     if (pixheight==0) pixheight= Nlm_screenRect.bottom - Nlm_screenRect.top - 120;
  176.             // these -## adjustments are not very good -- need to know what other
  177.             // views are in the given window and adjust for their size !?
  178.  
  179.     if (!itsSuperior) return; 
  180.     Nlm_GrouP prnt= (Nlm_GrouP)itsSuperior->GetNlmObject();
  181.     if (!prnt) return; 
  182.   Nlm_WindoW tempPort = Nlm_SavePort(prnt);
  183.   if (hasVscroll) scrollproc= richPanelScrollProc;
  184.   else scrollproc= NULL;
  185.   fPanel= Nlm_AutonomousPanel(prnt, pixwidth, pixheight, richPanelDrawProc,
  186.                                scrollproc, NULL, 0,
  187.                                NULL/*richPanelResetProc*/, NULL);
  188.   if (!fPanel) return; 
  189.   if (tempPort) Nlm_RestorePort(tempPort);
  190.   
  191.     Nlm_SetPanelClick(fPanel, richPanelClickProc, richPanelDragProc, richPanelHoldProc, 
  192.                                         richPanelReleaseProc);
  193.     this->SetNlmObject(fPanel);
  194.     this->SetAutoAdjust(true); // used after append/insert/replace/delete
  195.     this->SetSlateBorder(true);
  196.         
  197.     fStyles= new DList( ::richPanelCompareStyles ); //, DList::kDeleteObjects; // + DList::kOwnObjects 
  198.     fParags= new DList( ); // NULL, DList::kDeleteObjects;
  199.     //fStyles->fArrayIncrement= 30;
  200.     //fParags->fArrayIncrement= 30;
  201.     
  202.     if (gNotInitted) InitRichView();
  203.     fCurrentStyle= new DRichStyle();
  204.     ClearCurrentStyle();
  205.  
  206.     Nlm_LoadRect( &fDrawr, 0,0,0,0);
  207.     fAtpt.x= fAtpt.y= 0;
  208.             
  209.     DWindow* win= this->GetWindow();
  210.     if (win) {
  211.         win->fPrintHandler= this;
  212.         win->fSaveHandler= this;
  213.         }
  214. }
  215.     
  216.  
  217.  
  218.  
  219. DRichView::~DRichView()
  220. {
  221.     //?? need for SetDocData's DocFreeProc call...
  222.     //if (fStyles) delete fStyles; fStyles= NULL;
  223.     //if (fParags) delete fParags; fParags= NULL;
  224.         // damn, delete fList isn't calling object destructors !!!!
  225.     long i, n;
  226.     if (fStyles) {
  227.         n= fStyles->GetSize();
  228.         for (i=0; i<n; i++) {
  229.             DRichStyle* st= (DRichStyle*) fStyles->At(i);
  230.             if (st) delete st;
  231.             }
  232.         delete fStyles;
  233.         }
  234.     if (fParags) {
  235.         n= fParags->GetSize();
  236.         for (i=0; i<n; i++) {
  237.             DParagraph* pa= (DParagraph*) fParags->At(i);
  238.             if (pa) delete pa;
  239.             }
  240.         delete fParags;
  241.         }
  242.     if (fCurrentStyle) {
  243.         fCurrentStyle->ownpict= false;
  244.         delete fCurrentStyle;
  245.         }
  246. }
  247.  
  248. void  DRichView::DeleteAll() 
  249. {
  250.     short i, n;
  251.     if (fStyles) {
  252.         n= fStyles->GetSize();
  253.         for (i=0; i<n; i++) {
  254.             DRichStyle* st= (DRichStyle*) fStyles->At(i);
  255.             delete st;
  256.             }
  257.         fStyles->DeleteAll();
  258.         //delete fStyles;
  259.         }
  260.     if (fParags) {
  261.         n= fParags->GetSize();
  262.         for (i=0; i<n; i++) {
  263.             DParagraph* pa= (DParagraph*) fParags->At(i);
  264.             delete pa;
  265.             }
  266.         fParags->DeleteAll();
  267.         //delete fParags;
  268.         }
  269.     fNumItems= fNumLines= 0;
  270. }
  271.  
  272.  
  273.  
  274. void DRichView::InitRichView()
  275. {
  276.     gNotInitted= true;
  277.   for (short i = 0; i < MAXFONTS; i++) {
  278.     gFontHeights[i].font = NULL;
  279.     gFontHeights[i].height = 0;
  280.       }
  281.     gDrawPict = new DDrawPict();
  282. }
  283.  
  284.  
  285.  
  286. void DRichView::ViewRect( Nlm_RecT& r)  
  287. { 
  288.     DPanel::ViewRect( r);
  289.     Nlm_InsetRect(&r, 10, 4); 
  290. }
  291.  
  292.  
  293.  
  294.     
  295. void DRichView::SetSlateBorder(Boolean turnon) 
  296. {
  297.      Nlm_SetSlateBorder((Nlm_SlatE)fPanel, turnon);  
  298. }
  299.  
  300. void DRichView::SizeToSuperview( DView* super, Boolean horiz, Boolean vert)
  301. {
  302. #if 0
  303. #ifdef WIN_MOTIF
  304.     DPanel::SizeToSuperview( super, horiz, vert);
  305. #else
  306.     // size only lower and right sides == leave top area...
  307.     Nlm_RecT r, myr;
  308.     super->ViewRect(r);
  309.     GetPosition( myr); // ViewRect(myr); <<!!NO, diff from Get/SetPos
  310.     if (horiz)     myr.right= (r.right - r.left) +1;
  311.     // myr.right -= (Nlm_vScrollBarWidth - 8); // mswin patch !?
  312.     if (vert) myr.bottom =  (r.bottom - r.top)  +1; 
  313.     SetPosition( myr);
  314. #endif
  315. #endif
  316. }
  317.   
  318.  
  319. void DRichView::Resize(DView* superview, Nlm_PoinT sizechange)
  320. {
  321.     DPanel::Resize( superview, sizechange);
  322. }
  323.  
  324.  
  325.  
  326.  
  327.  
  328. DRichStyle* DRichView::GetStyle( short styleid)
  329. {
  330.     return (DRichStyle*) fStyles->At(styleid);
  331. }
  332.  
  333. DRichStyle* DRichView::GetStyleAtIndex(DParagraph* aParag, short styleindex)
  334. {    
  335.     short id= -1;
  336.     if (aParag) {
  337.         id= aParag->fStyleIndex[styleindex].styleid;
  338.         return (DRichStyle*) fStyles->At(id);  // id-1?? NO
  339.         }
  340.   else return NULL;
  341. }
  342.  
  343. DRichStyle* DRichView::GetStyleAtChar( DParagraph* aParag, short atchar)
  344. {
  345.     short id= -1;
  346.     if (aParag) {
  347.         short i;
  348.         for (i= aParag->fNumStyles-1; i>0; i--) { 
  349.             if (atchar >= aParag->fStyleIndex[i].nextofs) 
  350.                 break;
  351.             }
  352.         id= aParag->fStyleIndex[i].styleid; 
  353.         }
  354.     return (DRichStyle*) fStyles->At(id);  // id-1?? NO
  355. }
  356.  
  357. DRichStyle* DRichView::GetStyleAtChar( short atparag, short atchar)
  358. {
  359.     return GetStyleAtChar( (DParagraph*)fParags->At(atparag), atchar);
  360. }
  361.  
  362. short DRichView::FindOrAddStyle( DRichStyle* theStyle)
  363. { 
  364.     short styleid= fStyles->GetEqualItemNo( theStyle);
  365.     if (styleid == kEmptyIndex) {
  366.         DRichStyle* bst= new DRichStyle();
  367.         *bst= *theStyle;   // need a smart assign/copy method !! ?? a FIXED clone() ??
  368.         bst->ownpict= true;
  369.         theStyle->fObject= NULL; //theStyle->picdata= NULL;
  370.         fStyles->InsertLast(bst);
  371.         styleid= fStyles->GetSize() - 1;
  372.         }
  373.     return styleid;
  374. }
  375.  
  376.  
  377. DParagraph* DRichView::GetParaPtr( short item)
  378. { 
  379.     return (DParagraph*) fParags->At(item); 
  380. }
  381.  
  382.  
  383.  
  384. DParagraph* DRichView::MakeNewParag( void* data, short lines, 
  385.                         DParagraph* parFormat, DRichStyle* styles, short nstyles, Boolean docOwnsData)
  386. {
  387.     short ist, nst=0;
  388.     //if (styles) do nst++; while (!styles[nst-1].last);
  389.     StyleIndex* styleindex= (StyleIndex*) MemNew( nstyles*sizeof(StyleIndex));
  390.     for (ist=0; ist<nstyles; ist++) {
  391.         short id= FindOrAddStyle( &styles[ist]);
  392.         styleindex[ist].styleid= id;
  393.         styleindex[ist].nextofs= styles[ist].nextofs;
  394.         }
  395.     
  396.     return  new DParagraph( (char*)data, docOwnsData, lines, parFormat, styleindex, nstyles);
  397. }
  398.  
  399.  
  400. void     DRichView::AppendParag( DParagraph* aParag)
  401. {    
  402.   if (aParag) {
  403.         aParag->startsAt= fNumLines;
  404.     fNumLines += aParag->numRows;
  405.         fParags->InsertLast(aParag);
  406.     fNumItems++; // == fParags->GetSize();
  407.       }
  408. }
  409.  
  410. void     DRichView::Append( void* data, short lines, DParagraph* parFormat,  
  411.                         DRichStyle* styles, short nstyles, Boolean docOwnsData)
  412. {    
  413.     DParagraph* aParag= MakeNewParag( data, lines, parFormat, styles, nstyles, docOwnsData);
  414.   if (aParag) {
  415.     UpdateItemHeights(aParag);
  416.     AppendParag( aParag);
  417.     if (fAutoAdjust) AdjustScroll();
  418.       }
  419. }
  420.  
  421. void     DRichView::Insert( short item, void* data, short lines, DParagraph* parFormat, 
  422.                         DRichStyle* styles, short nstyles, Boolean docOwnsData)
  423. {
  424.     DParagraph* aParag= MakeNewParag( data, lines, parFormat, styles, nstyles, docOwnsData);
  425.   if (aParag) {
  426.     UpdateItemHeights(aParag);
  427.         DParagraph* pat= (DParagraph*)fParags->At(item);
  428.         if (pat) {
  429.             aParag->startsAt= pat->startsAt;
  430.             fParags->InsertBefore(item, aParag);
  431.         fNumLines = UpdateLineStarts(item);
  432.             fNumItems++; // == fParags->GetSize();
  433.         }
  434.       else {
  435.             AppendParag( aParag);    
  436.           }
  437.     if (fAutoAdjust) AdjustScroll();
  438.       }
  439. }
  440.  
  441. void     DRichView::Replace( short item, void* data, short lines, DParagraph* parFormat,  
  442.                 DRichStyle* styles, short nstyles, Boolean docOwnsData)
  443. {
  444.     DParagraph* aParag= MakeNewParag( data, lines, parFormat, styles, nstyles, docOwnsData);
  445.   if (aParag) {
  446.     UpdateItemHeights(aParag);
  447.         DParagraph* pat= (DParagraph*) fParags->At(item);
  448.         if (pat) {
  449.             aParag->startsAt= pat->startsAt;
  450.             fParags->AtPut(item, aParag);
  451.         fNumLines = UpdateLineStarts(item);
  452.             delete pat; // !? should DList do this on AtPut ?? it doesn't
  453.         }
  454.       else {
  455.             AppendParag( aParag);
  456.           }
  457.     if (fAutoAdjust) AdjustScroll();
  458.       }
  459. }
  460.  
  461.  
  462. void     DRichView::UpdateStyleHeight( DRichStyle* theStyle)
  463. {
  464.   if (theStyle) {
  465.       short theid= fStyles->GetIdentityItemNo( theStyle);
  466.         if (theid == kEmptyIndex) return;
  467.         
  468.       short j, item, nitem= fParags->GetSize();
  469.       for (item= 0; item<nitem; item++) {
  470.             DParagraph* pat= (DParagraph*) fParags->At(item);
  471.             for (j= 0; j< pat->fNumStyles; j++) {
  472.                 if (pat->fStyleIndex[j].styleid == theid) {
  473.                 short rtop, rbottom, firstline;
  474.                 UpdateItemHeights(pat);
  475.                 if (IsVisible( item, rtop, rbottom, firstline )) {
  476.                     Nlm_RecT    rec;
  477.                     ViewRect( rec);
  478.                         rec.top= rtop;
  479.                         InvalRect( rec);
  480.                     }
  481.                 break;
  482.                 }
  483.             }
  484.         }
  485.     if (fAutoAdjust) AdjustScroll();
  486.       }
  487. }
  488.  
  489.  
  490.  
  491.  
  492.  
  493. short DRichView::GetItemNum(short desiredLine)
  494. {
  495.     // Returns the number of the paragraph containing the desired line
  496.  
  497.   short mid = 1;
  498.   short left = 1;
  499.   short right = fNumItems;
  500.   Boolean goOn = TRUE;
  501.   while (left <= right && goOn) {
  502.     mid = (left + right) / 2;
  503.     DParagraph* aParag = GetParaPtr(mid - 1);
  504.     if (aParag) {
  505.       if (desiredLine < aParag->startsAt + aParag->numRows)  
  506.         right = mid - 1;
  507.       if (desiredLine >= aParag->startsAt)  
  508.         left = mid + 1;
  509.         } 
  510.     else {
  511.       goOn = FALSE;
  512.       mid = 1;
  513.         }
  514.   }
  515.   return mid - 1;
  516. }
  517.  
  518.  
  519.  
  520. void DRichView::SetStyle(DRichStyle* theStyle)
  521. {
  522.     if (!theStyle || theStyle->linkid || theStyle->ispict) 
  523.         return; /* do these styles separately */
  524.     if (theStyle->font != fCurrentStyle->font) 
  525.         Nlm_SelectFont(theStyle->font);
  526.     if (theStyle->color != fCurrentStyle->color)
  527.         Nlm_SetColor(theStyle->color);
  528.  
  529.     ZeroCharWidths();
  530.     *fCurrentStyle = *theStyle;
  531. }
  532.  
  533.  
  534. void DRichView::ClearCurrentStyle()
  535. {
  536.     fCurrentStyle->ispict= false;
  537.     fCurrentStyle->ismap= false;
  538.     fCurrentStyle->ownpict= false;
  539.     fCurrentStyle->fObject= NULL; //fCurrentStyle->picdata= NULL;
  540.     fCurrentStyle->font= NULL;
  541.     fCurrentStyle->superSub= 0;
  542.     fCurrentStyle->color= 0;
  543. }
  544.  
  545.  
  546.  
  547. short DRichView::CharWidth(char ch)
  548. {
  549.     unsigned char cw= fCharWidths[ch];
  550.     if (cw == kNoCharWidth) {
  551.         cw= Nlm_CharWidth(ch);
  552.          fCharWidths[ch]= cw;
  553.          }
  554.     return cw;
  555. }
  556.  
  557. void DRichView::ZeroCharWidths()
  558. {
  559.     Nlm_MemFill( fCharWidths, kNoCharWidth, 256); // sizeof(fCharWidths)
  560. }
  561.  
  562. short DRichView::StyleLineWidth(char* texts, short maxwid, DParagraph* itemPtr, short& istyle)
  563. {
  564.   Char               ch;
  565.   short              i,swid,wid,nextofs,numStyles;
  566.     Boolean         styleset;
  567.     DRichStyle * atstyle, savestyle;
  568.     
  569.   styleset= FALSE;
  570.   i = wid = swid = 0;
  571.     nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  572.     numStyles= itemPtr->fNumStyles;
  573.     atstyle= GetStyleAtIndex(itemPtr, istyle);
  574.     savestyle= *atstyle;
  575.     
  576.      if (atstyle->ispict) wid += atstyle->pixwidth; 
  577.     if (texts && maxwid > 0) {
  578.     ch = texts[i];
  579.     while (ch != '\0' && ch != '\n' && ch != '\r' && wid <= maxwid) {
  580.  
  581.       if (i>=nextofs && istyle<numStyles-1) {  // && !atstyle->last    
  582.                 ++istyle;
  583.                 nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  584.                 atstyle= GetStyleAtIndex(itemPtr, istyle);
  585.              SetStyle(atstyle);
  586.              styleset= TRUE;
  587.               if (atstyle->ispict) wid += atstyle->pixwidth; 
  588.         }
  589.         
  590.       else if (!atstyle->hidden) {
  591.             if (ch == '\t') {
  592.                         // fix this tab width !!!
  593.                   }
  594.             else wid += CharWidth(ch);
  595.           }
  596.       
  597.       i++;
  598.       ch = texts [i];
  599.         }
  600.       }
  601.     if (styleset) SetStyle( &savestyle);
  602.     savestyle.ownpict= false;
  603.   return wid;
  604. }
  605.  
  606.  
  607.  
  608. short DRichView::FitTextToWidth(char* texts, short maxwid, Boolean byPixels,
  609.                           DParagraph* itemPtr, short& istyle)
  610. {
  611.             // Returns the number of characters in the next block, including 
  612.             // trailing spaces (which are trimmed back later)
  613.   Char  ch;
  614.   short  i,j,wid, swid, nextofs, numStyles;
  615.     Boolean wordWrap, styleset;
  616.     DRichStyle *atstyle, savestyle;
  617.     
  618.     nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  619.     numStyles= itemPtr->fNumStyles;
  620.     atstyle= GetStyleAtIndex(itemPtr, istyle);
  621.     SetStyle(atstyle); // be sure ??
  622.     savestyle= *atstyle;
  623.     wordWrap= itemPtr->wrap;
  624.   i = j = 0;
  625.   wid = swid = 0;
  626.   if (texts && maxwid > 0) {
  627.     ch = texts [i];
  628.     while (ch != '\0' && ch != '\n' && ch != '\r' && wid <= maxwid) {
  629.       if (wordWrap) {
  630.           if (i>=nextofs && istyle<numStyles-1) {   //if (ch == chStyleTag) 
  631.                     ++istyle;
  632.                     nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  633.                     atstyle= GetStyleAtIndex(itemPtr, istyle);
  634.                SetStyle(atstyle);
  635.                styleset= TRUE;
  636.                 if (atstyle->ispict && byPixels) wid += atstyle->pixwidth; 
  637.             }
  638.             
  639.         else if (!atstyle->hidden) {
  640.               if (ch == '\t') {
  641.                         /* !!! FIX THIS !?!?! */
  642.                 }
  643.           else if (byPixels) wid += CharWidth (ch);
  644.           else wid++;
  645.             }
  646.           }
  647.       i++;
  648.       ch = texts [i];
  649.         }
  650.           
  651.     j = i;
  652.     if (wordWrap && wid > maxwid) {
  653.         // don't break in a word, and leave trailing spaces at end of line 
  654.       j--;
  655.       if (byPixels)  
  656.         while (Nlm_TextWidth(texts, i) >= maxwid)  i--;
  657.       else 
  658.         while (i >= maxwid) i--;
  659.       while (i > 0 && texts[i - 1] != ' ' && texts[i - 1] != '-')  i--;
  660.       while (texts [i] == ' ')  i++;
  661.         }
  662.         
  663.       }
  664.     if (styleset) SetStyle( &savestyle);
  665.     savestyle.ownpict= false; //!!
  666.   if (i > 0 && i < j) return i;
  667.     else if (j > 0) return j;
  668.     else  return 0;
  669. }
  670.  
  671.  
  672.  
  673.  
  674.  
  675.  
  676. void DRichView::ParseText(DParagraph* itemPtr, char* text, Boolean byPixels, Nlm_RecT r)
  677. {
  678.             //  Parses text that contains \t, \r and \n characters into a list of
  679.             //  cells organized by row and column
  680.  
  681.   char        ch, just;
  682.   short       inset,
  683.             istyle, numStyles, col, blklen, len,width,maxwid,
  684.                       numRows,tabRow,returnRow,row;
  685.   Uint2        start;
  686.   Boolean      wrap;
  687.     char          * newtex;
  688.     ulong         maxsize, newsize;
  689.     
  690.   if (itemPtr && text && *text != '\0') {
  691.       numStyles= itemPtr->fNumStyles;
  692.        istyle= 0;
  693.     if (numStyles) {
  694.         DRichStyle savestyle;
  695.         savestyle= *fCurrentStyle;
  696.         ClearCurrentStyle();
  697.         SetStyle(GetStyleAtIndex(itemPtr, istyle));
  698.         
  699.         if (*text == '\n' && text[1] == '\0') {
  700.             // ?? Win32 bug - failing w/ multiple '\n's ??!!
  701.             newtex = (char*) MemNew (5 + itemPtr->minLines);
  702.                newtex[0]= '\n';
  703.               newtex[1]= '\0';
  704.         itemPtr->numRows = MAX (1, itemPtr->minLines);
  705.               itemPtr->fText = newtex;
  706.               SetStyle(&savestyle);
  707.               savestyle.ownpict= false; // !!
  708.               return;
  709.               }
  710.               
  711.           maxsize= (ulong) (StrLen(text) + 50 + itemPtr->minLines);
  712.           newsize= 0;
  713.           newtex = (char*) MemNew (maxsize);
  714.          
  715.       width = 0;
  716.       inset = itemPtr->leftInset; /* pixLeft, pixFirst ?? */
  717.       just = itemPtr->just; /*'l';*/
  718.       wrap = itemPtr->wrap; /* TRUE; /* fix this as choice ... */
  719.       start = 0;
  720.       row = 0;
  721.       tabRow = 0;
  722.       returnRow = 1;
  723.       col = 0;
  724.       numRows = 0;
  725.       while (text[start] != '\0') {
  726.         ch = text[start];
  727.         if (ch != '\0' && ch != '\n' && ch != '\r'  ) {
  728.           maxwid =  r.right - r.left - 15; // !!! Need PAGEWIDTH here !!
  729.           short istyle0= istyle;                    
  730.           blklen =  FitTextToWidth(text + start, maxwid, byPixels, 
  731.                               itemPtr, istyle);
  732.                 if (istyle!=istyle0) SetStyle(GetStyleAtIndex(itemPtr, istyle));
  733.           len = blklen;
  734.           
  735.           if (len > 0) {
  736.             if (text[start + len] != '\0') { // eat trailing spaces 
  737.               while (len > 0 && text [start + len - 1] == ' ') len--;
  738.               if (len == 0) len = blklen;
  739.                 }
  740.             if (newsize+len > maxsize) {
  741.                 maxsize= newsize+len+100;
  742.                 newtex= (char*) MemMore(newtex, maxsize);  
  743.                 }
  744.             MemCpy( newtex+newsize, text+start, len);
  745.             newsize += len;
  746.             start += blklen;
  747.               } 
  748.               
  749.           else { // len==0, shouldn't be true ? 
  750.  
  751.               }
  752.             }
  753.             
  754.         ch = text [start];
  755.         if (ch == '\n') {
  756.                  newtex[newsize++]= '\n';
  757.               start++;
  758.           row = returnRow;
  759.           tabRow = row;
  760.           returnRow++;
  761.           col = 0;
  762.             } 
  763.         else if (ch == '\r') {
  764.                  newtex[newsize++]= '\n';
  765.           start++;
  766.           row++;
  767.           returnRow = MAX (returnRow, row + 1);
  768.                } 
  769. #if 0
  770.         else if (ch == '\t') {
  771.           start++;
  772.           row = tabRow;
  773.               newtex[newsize++]= '\t';
  774.           if (text [start] == '\0') row = returnRow;
  775.             } 
  776. #endif
  777.         else if (ch != '\0' && wrap) {
  778.               newtex[newsize++]= '\n';
  779.           if (len == 0) start++;
  780.           row++;
  781.           returnRow = MAX (returnRow, row + 1);
  782.             } 
  783.         else if (ch != '\0') 
  784.             start++;
  785.         else if (text [start - 1] != '\n' && text [start - 1] != '\r')  
  786.           row = returnRow;
  787.          
  788.         numRows = MAX (numRows, row);
  789.           }
  790.       itemPtr->numRows = MAX (numRows, itemPtr->minLines);
  791.             newtex[newsize++]= '\0';
  792.             itemPtr->fText = newtex;
  793.             SetStyle(&savestyle);
  794.             savestyle.ownpict= false; // !!
  795.         }
  796.       } 
  797.   else if (itemPtr != NULL)  
  798.     itemPtr->numRows = 0;
  799. }
  800.  
  801.  
  802.  
  803.  
  804.  
  805. // temp globals...
  806.  
  807. static short gMapOfs = 0;
  808. //static DRichStyle* gMapStyle = NULL;
  809.  
  810. short DRichView::DrawStyledItem(DParagraph* itemPtr, Nlm_RectPtr rpara, short item,
  811.                                       short frst, Boolean forPrinter, Nlm_PoinT* mapPoint)
  812. {
  813.                 // Draws a given paragraph(item) on the screen, using parag & char styles 
  814.   char         ch, just, csave;
  815.   Boolean      isnewline, bartab, dotab, mapPt, drawSelection, gray, doborder;
  816.   char         * ptext, * text;
  817.   unsigned long            nextofs;
  818.   short     lineHeight, num, row, rsult, rleft, rright, rbottom, width, maxwid,
  819.                          istyle,styleid, istyle2, numStyles, superSub, txtwidth, yfont; 
  820.                       
  821.   DRichStyle    * astyle;  
  822.   Nlm_RecT         rct; // drw
  823.     Nlm_PoinT            pt1, pt2; //, atpt;
  824.     
  825.     mapPt= (mapPoint != NULL);
  826.     if (mapPt) fMapStyle= NULL;
  827.     fDodraw= (mapPoint == NULL);
  828.     drawSelection= (fSelected && fDodraw && !forPrinter 
  829.                                     && item >= fSelParag && item <= fSelEndParag);
  830.   rsult = 0;
  831.   if (itemPtr && rpara) {
  832.     text = itemPtr->fText;
  833.     numStyles= itemPtr->fNumStyles;
  834.     
  835.     if (text && *text != '\0') {
  836.         just= itemPtr->just;
  837.       lineHeight = itemPtr->lineHeight;
  838.       rct.top = rpara->top;
  839.       rct.bottom = rct.top;
  840.             rbottom = rct.top + lineHeight * (itemPtr->numRows - frst);
  841.              rleft= fAtpt.x = rpara->left + itemPtr->leftInset + itemPtr->firstInset;
  842.       fAtpt.y = rpara->top;
  843.       row = 0;
  844.       txtwidth= 0;
  845.       ptext = text;
  846.       ch = *ptext;
  847.           gray = FALSE;
  848.             isnewline= TRUE;
  849.  
  850. //Debug("1");
  851.          istyle= 0;
  852.          styleid= itemPtr->fStyleIndex[istyle].styleid;
  853.          nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  854.              astyle= GetStyle(styleid);
  855.  
  856.             Nlm_LoadRect(&fDrawr, rleft, rpara->top, rpara->right, rbottom);
  857.             
  858.       if (itemPtr->newPage) {
  859.           /* probably on line by self... */
  860.           /* record footnote text somewhere and dump out here before page break... */
  861.           if (fDodraw && !forPrinter) {
  862.                     Nlm_Dashed(); // Nlm_Dotted(); 
  863.                 Nlm_FrameRect(&fDrawr);
  864.                     Nlm_ResetDrawingTools();
  865.                     }
  866.           }
  867.                        
  868.          ClearCurrentStyle();
  869.          SetStyle(astyle);
  870.             superSub= astyle->superSub;
  871.             
  872.       while (ch != '\0') {
  873.       
  874.         if (ch == '\n') {
  875.           rct.top = rpara->top + (row - frst) * lineHeight;
  876.           rct.bottom = rct.top + lineHeight;
  877.             rleft= fAtpt.x = rpara->left + itemPtr->leftInset;
  878.           row++;
  879.           ptext++; 
  880.           isnewline= TRUE;
  881. //Debug("/");
  882.             } 
  883.                     
  884.         else if (ch == chPictTag) {
  885.           ptext++;
  886.             } 
  887.            
  888.         else  {
  889.         
  890.                     while ( (ptext - text >= nextofs) && (istyle < numStyles-1)) {
  891. //Debug("s");
  892.                      istyle++;
  893.                      styleid= itemPtr->fStyleIndex[istyle].styleid;
  894.                      nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  895.                      if (!((ptext - text >= nextofs) && (istyle < numStyles-1))) {
  896.                              astyle= GetStyle(styleid);
  897.                          SetStyle(astyle);
  898.                             superSub= astyle->superSub;
  899.                             }
  900.                         }
  901.  
  902.                   if (isnewline) {
  903.                          doborder= itemPtr->DoBorder();
  904.  
  905.                 if (just != 'l') {
  906.                     istyle2= istyle;
  907.                   maxwid=  rpara->right - rpara->left; //!!! Need PAGEWIDTH here !!
  908.                              width= StyleLineWidth( ptext, maxwid, itemPtr, istyle2);
  909.                              if (width<maxwid) {
  910.                                  switch (just) {
  911.                                      case 'r': 
  912.                                          fAtpt.x= /*rleft= */ MAX( rleft, rpara->right - itemPtr->rightInset - width); 
  913.                                          break;
  914.                                      case 'c': { 
  915.                                          short rhalf= ((rpara->right - itemPtr->rightInset - rleft) - width) / 2; 
  916.                                          if (rhalf>0) fAtpt.x= rleft += rhalf;
  917.                                          }
  918.                                          break;
  919.                                      }
  920.                                  }
  921.                     }
  922.                       isnewline= FALSE;
  923.                       }
  924.                       
  925.                 num = 0;
  926.                 while ( ch == '\t') ch= ptext[++num];
  927.           while ( ch != '\0' && ch != '\n' && ch != '\t' 
  928.               && ( (num + ptext - text) < nextofs))   
  929.                 ch = ptext[++num];
  930.  
  931.           if (row >= frst) {
  932.                     Boolean inrect;
  933.  
  934.  //Debug("r");
  935.             rct.top = rpara->top + (row - frst) * lineHeight;
  936.             rct.bottom = rct.top + lineHeight;
  937.             rct.left = fAtpt.x;  
  938.             rct.right = rpara->right - itemPtr->rightInset; 
  939.                         if (doborder && row == itemPtr->numRows-1 
  940.                             && (itemPtr->borderbottom || itemPtr->borderbox)) 
  941.                                 rct.bottom--;
  942.             Nlm_LoadRect (&fDrawr, MAX (rct.left, rpara->left), rct.top,
  943.                       MIN (rct.right, rpara->right), rct.bottom);
  944.  
  945. #if 1
  946.                         inrect= (rct.top <= rpara->bottom && rct.bottom > rpara->top);
  947. #else
  948.                          inrect= Nlm_SectRect( &fDrawr, rpara, &rsect);
  949. #endif
  950.             if ( inrect && (mapPt || forPrinter || Nlm_updateRgn == NULL ||
  951.                      Nlm_RectInRgn (&rct, Nlm_updateRgn))) {
  952.               fDrawr = rct;
  953.                             fDrawr.top += superSub; 
  954.                             fDrawr.bottom += superSub;  
  955. // Debug1("%d",num);
  956.               if (num > 0  && !(astyle->hidden)) {
  957. // Debug("i");
  958.                   just= 'l';
  959.                        bartab= FALSE;
  960.                      dotab= FALSE;
  961.  
  962.                         /* yfont= fDrawr.top + Nlm_Ascent();  /* a. large font mismatch */
  963.                            /* yfont= fDrawr.bottom - Nlm_Descent() - Nlm_Leading(); /* b. better than a */
  964.                            /* yfont= fDrawr.bottom - Nlm_Descent(); /* c. almost perfect, slight font mismatch */
  965.                         /* yfont= fDrawr.top + Nlm_FontHeight(); /* d. bad, too low, font mismatch */
  966.                            yfont= fDrawr.bottom - 4; /* Nlm_stdDescent; /* e. !! YES, but what is right ## ?? */
  967.                            /* yfont= fDrawr.top + Nlm_FontHeight() - Nlm_Descent(); /* f. ?? */
  968.  
  969.                 while (num > 0 && *ptext == '\t') {
  970.                   dotab= TRUE;
  971.                   num--;
  972.                   ptext++;
  973.                                     itemPtr->SetTab( *ptext == '\t', rleft, fDrawr, rpara, bartab, just);
  974.                     fAtpt.x = fDrawr.left; /* ??? */
  975.                     }
  976.                     
  977.                             if (dotab) 
  978.                                 itemPtr->DrawTab( this, rct, fDrawr, fAtpt, yfont, bartab, fDodraw);
  979.  
  980.                     if (astyle->allcaps || astyle->smallcaps) { 
  981.                         char* cp= ptext;
  982.                         for (short i=0; i<num; i++) cp[i]= to_upper(cp[i]);
  983.                             // need to shift fontsize down for lowercases 
  984.                         }
  985.  
  986.                         txtwidth= Nlm_TextWidth(ptext, num); 
  987.                          
  988.                   switch (just) {
  989.                          case 'c': 
  990.                              rright= (fDrawr.left + txtwidth + fDrawr.right)/ 2; 
  991.                                         fDrawr.left += (fDrawr.right - fDrawr.left - txtwidth) / 2; 
  992.                              break;
  993.                          case 'r':
  994.                              rright = fDrawr.right; 
  995.                              fDrawr.left = fDrawr.right - txtwidth; 
  996.                              break;
  997.                          default:
  998.                          case 'l':
  999.                                    /* rright= fDrawr.left + astyle->pixwidth; */
  1000.                                 rright= fDrawr.left + txtwidth + 1;
  1001.                              break;
  1002.                          }
  1003.                          
  1004.                      /* these are no good for multilines w/ same style, & resizing changes */
  1005.                                 if (astyle->pixwidth==0) astyle->pixwidth= rright - fAtpt.x;
  1006.                                 astyle->pixleft= fAtpt.x;
  1007.  
  1008. #if 0
  1009.     // this looks too messy !!
  1010.     // ?? quick fix for html text that is off screen to left or right ?
  1011.                                 if (rright > rpara->right) Nlm_OffsetRect( &fDrawr, rpara->right-rright, 0);
  1012.                                 if (fDrawr.left < rpara->left) fDrawr.left= rpara->left;
  1013. #endif
  1014.                                 
  1015.                      Nlm_MoveTo(fDrawr.left, yfont);  // yfont == adjust for leading
  1016.                      if (fDodraw) {
  1017.                          csave= ptext[num]; ptext[num]= 0;
  1018.                          Nlm_PaintString(ptext);
  1019.                      ptext[num]= csave;                                    
  1020.                               }
  1021.  
  1022.                      else if (mapPoint && Nlm_PtInRect( *mapPoint, &fDrawr)) {
  1023.                          if (astyle->ispict) {
  1024. #if 0
  1025.                                         astyle->fObject->FindPt( fDrawr, pt);
  1026.                                         // return isInPict && point-rel to pict && astyle or styleid !!
  1027. #endif
  1028.                                 fAtpt.x= rright;
  1029.                              fDrawr.left= fAtpt.x;  
  1030.                              gMapOfs= (short)(ptext - text); // pict point ??
  1031.                            fMapStyle= astyle;
  1032.                              return gMapOfs; // text point..
  1033.                              }
  1034.                          else {
  1035.                              // return also num chars !?
  1036.                              short atx= mapPoint->x - fDrawr.left;
  1037.                              short    i= num;
  1038.                              if (Nlm_TextWidth(ptext, i) >= atx) {
  1039.                                  while (i>0 && Nlm_TextWidth(ptext, i) > atx) i--;
  1040.                                  gMapOfs= (short)(ptext + i - text);
  1041.                                             fMapStyle= astyle;
  1042.     
  1043.                                      // !! not finding proper style (for links)
  1044.                                  short ist= istyle;
  1045.                                  short nof= nextofs;
  1046.                                  short sid= styleid;
  1047.                                  while ( gMapOfs >= nof && ist < numStyles-1 ) {
  1048.                                              ist++;
  1049.                                              sid= itemPtr->fStyleIndex[ist].styleid;
  1050.                                              nof= itemPtr->fStyleIndex[ist].nextofs;
  1051.                                                 fMapStyle= GetStyle(sid);
  1052.                                                 }
  1053.                                  return gMapOfs; // text point..
  1054.                                  }
  1055.                              else {
  1056.                                  // ??? continue on for more of ptext, if proper line ...
  1057.                                  // there must be some mistake in fDrawr if we get here??
  1058.                                  }
  1059.                              }
  1060.                          }
  1061.  
  1062.                                 if (astyle->linkid && fDodraw) {
  1063.                                   if (!forPrinter) {
  1064.                                          Nlm_SetColor(astyle->color);
  1065. #if 1
  1066.                                         Nlm_WidePen(2);
  1067.                                         /* Nlm_Dotted(); /* Nlm_Dashed(); */
  1068.                                         Nlm_MoveTo( fDrawr.left, fDrawr.bottom-2);
  1069.                                         Nlm_LineTo( rright-1, fDrawr.bottom-2);
  1070.                                         Nlm_WidePen(1);
  1071.                                         Nlm_Solid();
  1072. #else
  1073.                                         fDrawr.right= rright-1;
  1074.                                         Nlm_FrameRect( &fDrawr);
  1075. #endif
  1076.                                         Nlm_SetColor(fCurrentStyle->color);
  1077.                                         }
  1078.                                     }
  1079.                                 else if (astyle->boxed && fDodraw) {
  1080.                                     fDrawr.right= rright-1;
  1081.                                     Nlm_FrameRect( &fDrawr);
  1082.                                     }
  1083.  
  1084.                                 Nlm_Black(); /* need this or something like to fix color bug in XWin */
  1085.  
  1086.                                 if (drawSelection) {
  1087.                                     short textofs= ptext - text; 
  1088.                                     short textend= textofs + num; 
  1089.                                     Nlm_RecT selr= fDrawr;
  1090.                                     Boolean showsel= true;
  1091.                                     short  baseleft= selr.left;
  1092.                                     
  1093.                                     if (item == fSelParag) {
  1094.                                         if (textend < fSelChar) showsel= false;
  1095.                                         if (showsel && textofs < fSelChar) 
  1096.                                             selr.left = MIN( selr.right, 
  1097.                                                 baseleft + Nlm_TextWidth( ptext, fSelChar - textofs));
  1098.                                         }
  1099.                                         
  1100.                                     if (showsel && item == fSelEndParag) {
  1101.                                       if (textofs > fSelEndChar) showsel= false;
  1102.                                         if (showsel && textofs < fSelEndChar) //textend > fSelEndChar
  1103.                                             selr.right = MAX(selr.left, 
  1104.                                                 baseleft + Nlm_TextWidth( ptext, fSelEndChar - textofs));
  1105.                                         }
  1106.  
  1107.                                     if (showsel) Nlm_InvertRect( &selr);
  1108.                                     }
  1109.                                     
  1110.                                     
  1111.                         fAtpt.x= rright;
  1112.  
  1113.                    if (astyle->strikeout && fDodraw) {
  1114.                        short dmid= (fDrawr.top + fDrawr.bottom) / 2;
  1115.                        Nlm_MoveTo( fDrawr.left, dmid);
  1116.                        Nlm_LineTo( fAtpt.x, dmid);
  1117.                        }
  1118.                      fDrawr.left= fAtpt.x;  
  1119.  
  1120.                                 if (astyle->ispict) {
  1121.                                     fDrawr.right = fDrawr.left + astyle->pixwidth;
  1122.                                     fDrawr.bottom= fDrawr.top + astyle->pixheight;
  1123.                                   fAtpt.x= fDrawr.right+1;
  1124.                                     if (fDodraw) {
  1125.                                         if (astyle->fObject) astyle->fObject->Draw( fDrawr);
  1126.                                         Nlm_ResetDrawingTools();
  1127.                                         }
  1128.                                     fDrawr.left= fAtpt.x;
  1129.                                     }
  1130.                    }
  1131.                  fDrawr.right = rct.right;
  1132.               
  1133.                             if (doborder && fDodraw) {
  1134.                                 itemPtr->DrawBorder( this, row, item, rpara, rct);
  1135.                                  doborder= FALSE;
  1136.                                 }
  1137.  
  1138.               }
  1139.               }
  1140.                     if (!num) ptext++; else ptext += num;
  1141.             }
  1142.         ch = *ptext;
  1143.              }
  1144.       rct.top = rct.bottom;
  1145.       rsult = rct.top - rpara->top;
  1146.         }
  1147.     Nlm_SelectFont(Nlm_programFont);  //Nlm_systemFont
  1148.       }
  1149.   if (mapPt) return -1;   // couldn't find mapPoint if we got here
  1150.   else return rsult;
  1151. }
  1152.  
  1153.  
  1154.  
  1155.  
  1156.  
  1157. char* DRichView::DataToChar(char* ptr)  
  1158. {
  1159.   if (ptr) 
  1160.     return Nlm_StringSave((char*)ptr);
  1161.   else 
  1162.     return NULL;
  1163. }
  1164.  
  1165.  
  1166. void DRichView::FormatText( short item, DParagraph* itemPtr, Boolean byPixels)
  1167. {
  1168.         // parses and rearranges the text so that it can be displayed, saved, or printed
  1169.   char           ch;
  1170.   Boolean        needToParse;
  1171.   short       numRows;
  1172.   char*            text;
  1173.     Nlm_RecT        r;
  1174.     
  1175.     /* dgg &fix this */
  1176.  
  1177.   if (itemPtr && itemPtr->fText == NULL) {
  1178.         this->ViewRect( r);
  1179.     needToParse = TRUE;
  1180.         text = this->DataToChar(itemPtr->fDataPtr);
  1181.           
  1182.     if (needToParse && text && *text != '\0') {
  1183.           if (*text == '\n' && text[1] == '\0') {
  1184.           itemPtr->fText = text;
  1185.           itemPtr->numRows = 1;
  1186.                }
  1187.       else {
  1188.           ParseText(itemPtr, text, byPixels, r);
  1189.           MemFree(text);
  1190.           }
  1191.       itemPtr->notCached = FALSE;
  1192.       itemPtr->neverCached = FALSE;
  1193.         } 
  1194.     else  
  1195.       itemPtr->fText = text;
  1196.      
  1197.     text = itemPtr->fText;
  1198.     if (text == NULL || *text == '\0') {
  1199.       MemFree(itemPtr->fText);
  1200.       itemPtr->fText = StringSave(" \n");
  1201.       itemPtr->numRows = 1;
  1202.       itemPtr->notCached = FALSE;
  1203.       itemPtr->neverCached = FALSE;
  1204.         } 
  1205.     else if (fIsVirtual) {
  1206.       numRows = 0;
  1207.       ch = *text;
  1208.       while (ch != '\0') {
  1209.         if (ch == '\n') numRows++;
  1210.         text++;
  1211.         ch = *text;
  1212.           }
  1213.       numRows = MAX (1, numRows);
  1214.       itemPtr->numRows = MAX (numRows, itemPtr->minLines);
  1215.         }
  1216.   }
  1217. }
  1218.  
  1219.  
  1220. short DRichView::GetLineStart(short item)
  1221. {
  1222.             // Returns the first line of the item
  1223.   DParagraph*  itemPtr = GetParaPtr(item);  
  1224.   if (itemPtr) return itemPtr->startsAt;
  1225.   else return 0;
  1226. }
  1227.  
  1228. short DRichView::GetNumRows(short item)
  1229. {
  1230.                 //   Returns the number of rows in the item
  1231.   DParagraph*  itemPtr  = GetParaPtr( item);  
  1232.   if (itemPtr)  return itemPtr->numRows;
  1233.   else return 0;
  1234. }
  1235.  
  1236. short DRichView::GetLineHeight(short item)
  1237. {
  1238.         //     Returns the pixel height of the item
  1239.   DParagraph*  itemPtr  = GetParaPtr( item);  
  1240.   if (itemPtr)  return itemPtr->lineHeight;
  1241.   else return 0;
  1242. }
  1243.  
  1244.  
  1245.  
  1246.  
  1247.     
  1248. Boolean DRichView::Doc2ViewOffset(short& xoff, short& yoff)
  1249. {
  1250.   Nlm_RecT             viewr, rct;
  1251.   short             atline, itemNum, leadHeight, lineHeight, numRows, off;
  1252.   Nlm_BaR          sb;
  1253.   DParagraph*      itemPtr;
  1254.     
  1255.     ViewRect( viewr);
  1256.     Nlm_LoadRect( &rct, 0, 0, viewr.right - viewr.left, 0);
  1257.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  1258.     if (sb) off = Nlm_GetValue(sb); // line offset of view
  1259.     else off= 0;
  1260.     
  1261.     //for (atline=0; atline<= off; atline++)  
  1262.     atline = 0;
  1263.     leadHeight = 0;
  1264.     itemNum = 0; //= GetItemNum( atline);
  1265.     while (itemNum < fNumItems && atline < off) {
  1266.         itemPtr = GetParaPtr( itemNum);
  1267.       if (itemPtr) {
  1268.             rct.top = rct.bottom + leadHeight;
  1269.       CacheIfNever( itemNum + 1, itemPtr, &viewr);
  1270.           if (atline>0) rct.top += itemPtr->spaceBefore;
  1271.       lineHeight = itemPtr->lineHeight;
  1272.       rct.top += leadHeight;
  1273.       numRows = itemPtr->numRows;
  1274.       rct.bottom = rct.top + lineHeight * (numRows) + itemPtr->spaceAfter;
  1275.            leadHeight = itemPtr->leadHeight;
  1276.           atline += numRows;
  1277.             }
  1278.         itemNum++;
  1279.         }
  1280.  
  1281.     xoff = rct.left;
  1282.     yoff = rct.top; // - viewr.top; // ??? was +top
  1283.     return true;
  1284. }    
  1285.  
  1286.     
  1287. Boolean DRichView::MapDoc2View( Nlm_RecT& selr)
  1288. {
  1289.   Nlm_RecT     viewr, rct;
  1290.     short        xoff, yoff;
  1291.  
  1292.     Doc2ViewOffset(xoff, yoff);
  1293.     selr.left         -= xoff;
  1294.     selr.right     -= xoff;
  1295.     selr.top         -= yoff;
  1296.     selr.bottom -= yoff;
  1297.     
  1298.     ViewRect( viewr);
  1299. #ifdef DBUG
  1300.     return true;        // !! SectRect always false for WIN_MOTIF !!!!!        
  1301. #else
  1302.     Boolean visible= Nlm_SectRect( &selr, &viewr, &rct);
  1303.     return visible;
  1304. #endif
  1305. }
  1306.  
  1307. void DRichView::MapView2Doc( Nlm_RecT& selr)
  1308. {
  1309.     short        xoff, yoff;
  1310.     
  1311.     Doc2ViewOffset(xoff, yoff);
  1312.     selr.left         += xoff;
  1313.     selr.right     += xoff;
  1314.     selr.top         += yoff;
  1315.     selr.bottom += yoff;
  1316. }
  1317.     
  1318. void DRichView::MapView2Doc( Nlm_PoinT& mpt)
  1319. {
  1320.     short        xoff, yoff;
  1321.     
  1322.     Doc2ViewOffset(xoff, yoff);
  1323.     mpt.x         += xoff;
  1324.     mpt.y         += yoff;
  1325. }
  1326.  
  1327.  
  1328. Boolean    DRichView::HiliteText(short startparag, short startchar, 
  1329.                                                             short endparag, short endchar, Boolean turnon) 
  1330. { 
  1331.             // Finds the visible region of an startparag in a document
  1332.   short             firstItem, fstLine, itemNum, leadHeight,lineHeight, numRows, off;
  1333.   Nlm_RecT         viewr, rct;
  1334.   Boolean              goOn, rsult;
  1335.   Nlm_BaR          sb;
  1336.   DParagraph*      itemPtr;
  1337.  
  1338.   rsult = FALSE;
  1339.      //top = 0;
  1340.      //bottom = 0;
  1341.   //firstline = 0;
  1342.  
  1343.     ViewRect( viewr);
  1344.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  1345.   if (sb) off = Nlm_GetValue(sb);
  1346.   else off= 0;
  1347.   if (startparag >= 0 && startparag < fNumItems) {
  1348.     goOn = TRUE;
  1349.     Nlm_LoadRect(&rct, viewr.left, viewr.top, viewr.right, viewr.top);
  1350.     itemNum = GetItemNum( off);
  1351.     itemPtr = GetParaPtr( itemNum);
  1352.     if (itemPtr) {
  1353.       fstLine = off - itemPtr->startsAt;
  1354.       firstItem = itemNum;
  1355.       lineHeight = 0;
  1356.       leadHeight = 0;
  1357.       numRows = 0;
  1358.       while (goOn && itemNum < fNumItems && itemNum <= startparag) {
  1359.         itemPtr = GetParaPtr( itemNum);
  1360.         if (itemPtr) {
  1361.           CacheIfNever( itemNum + 1, itemPtr, &viewr);
  1362.           if (itemNum > firstItem)  
  1363.             leadHeight = itemPtr->leadHeight;
  1364.             else  
  1365.             leadHeight = 0;
  1366.               if (fstLine==0) rct.top += itemPtr->spaceBefore;
  1367.           
  1368.           lineHeight = itemPtr->lineHeight;
  1369.           rct.top += leadHeight;
  1370.           numRows = MIN (itemPtr->numRows,
  1371.                          MAX ((viewr.bottom - rct.top) / lineHeight, 0));
  1372.           rct.bottom = rct.top + lineHeight * (numRows - fstLine);
  1373.               rct.bottom += itemPtr->spaceAfter;
  1374.           if (itemNum == startparag) {
  1375.             //goOn = FALSE;
  1376.             if (numRows > 0) {
  1377.                 //top = rct.top;
  1378.                 //bottom = rct.bottom;
  1379.                 //firstline = fstLine;
  1380.                 fSelRect.top= rct.top;
  1381.                 fSelRect.bottom= rct.bottom;
  1382.                 //gMapOfs
  1383.                 fSelRect.left= rct.left; // this is bogus, just is left edge...
  1384.                 fSelRect.right= rct.right; // this also is bogus
  1385.               rsult = TRUE;
  1386.                 }
  1387.               } 
  1388.           else  
  1389.             rct.top = rct.bottom;
  1390.           if (numRows < itemPtr->numRows)  
  1391.             goOn = FALSE;
  1392.             }
  1393.         itemNum++;
  1394.         fstLine = 0;
  1395.           }
  1396.         }
  1397.       }
  1398.     fSelRect.bottom= rct.bottom; //????
  1399.      MapView2Doc( fSelRect); //?? need to get it working ??
  1400.   return rsult;
  1401. }
  1402.  
  1403.  
  1404.  
  1405.  
  1406. void DRichView::HiliteSelection(Boolean turnon)
  1407. {
  1408.     if (fSelected) {
  1409.         Nlm_RecT viewr, selr;
  1410.         
  1411.         selr= fSelRect;
  1412.         Boolean visible= MapDoc2View( selr);
  1413.         // !! must map sel location to current view (w/ sb) and see if it
  1414.         // is in view window !!
  1415.         
  1416.         if (!visible) 
  1417.             return;
  1418.         else {
  1419.                 // getting cases where this is called when this view's window is NOT front
  1420.             //DWindow* savewin=  gWindowManager->SavePort(this);
  1421.             if (fSelInPict) {
  1422.                 //Nlm_InvertRect( &selr);
  1423.                 Nlm_InvertMode();
  1424.                 Nlm_FrameRect( &selr);
  1425.                 Nlm_CopyMode();
  1426.                 }
  1427.             else {
  1428.                 ViewRect( viewr);
  1429.                 selr.left= viewr.left;
  1430.                 selr.right= viewr.right;
  1431.                 selr.top= MAX( viewr.top, selr.top - 20);  // expand inval area for full line
  1432.                 selr.bottom = MIN( viewr.bottom, selr.bottom ); 
  1433.                 InvalRect( selr); // let DrawStyledItem do work ?
  1434.                 Boolean savesel= fSelected;
  1435.                 fSelected= turnon;
  1436.                 Nlm_Update();  // this->Draw();
  1437.                 fSelected= savesel;
  1438.                 }
  1439.             //if (savewin) gWindowManager->RestorePort(savewin);
  1440.             }
  1441.         }
  1442. }
  1443.  
  1444. void DRichView::ClearSelection()
  1445. {
  1446.         //?? before unHilite to cure draw bug ??
  1447.     fSelParag= fSelChar= fSelEndParag= fSelEndChar= 0;
  1448.     HiliteSelection(false);
  1449.     //fSelParag= fSelChar= fSelEndParag= fSelEndChar= 0;
  1450.     fSelInPict= false;
  1451.     fSelected= false;
  1452. }
  1453.  
  1454.  
  1455. void DRichView::SetSelectedText( short startparag, short startchar, 
  1456.                                                                     short endparag, short endchar)
  1457. {
  1458.     ClearSelection(); // clear any old sel -- i.e., wipe view markings
  1459.     fSelInPict= false; //!! check if selrect is in a picture !!
  1460.     fSelParag    = Max(0, Min(startparag, fNumItems));      
  1461.     fSelChar    = Max(0, startchar);          // check max !? 
  1462.     
  1463.     fSelEndParag    = Max(0, Min(endparag, fNumItems));      
  1464.     // if endchar==0 endchar== maxchar ??
  1465.     fSelEndChar      = Max(0, endchar);     // check max !? 
  1466.     fSelected= (fSelParag > 0 || fSelChar > 0 || fSelEndChar > 0);
  1467.  
  1468.             // !! NEED THIS parag/char -> fSelRect mapper !!
  1469.     if (HiliteText( fSelParag, fSelChar, fSelEndParag, fSelEndChar, false) ) ;
  1470.  
  1471.     HiliteSelection(fSelected);
  1472. }
  1473.  
  1474. void DRichView::SelectAll()
  1475. {
  1476.     short                    itemNum, leadHeight, atline;
  1477.   Nlm_RecT            viewr, rct;
  1478.   DParagraph*      itemPtr;
  1479.     
  1480.     ClearSelection(); // clear any old sel -- i.e., wipe view markings
  1481.     ViewRect( viewr);
  1482.     Nlm_LoadRect( &rct, 0, 0, viewr.right - viewr.left, 0);
  1483.     atline = 0;
  1484.     leadHeight = 0; 
  1485.     itemNum = 0; //= GetItemNum( atline);
  1486.     while (itemNum < fNumItems) {
  1487.         itemPtr = GetParaPtr( itemNum);
  1488.       if (itemPtr) {
  1489.       CacheIfNever( itemNum + 1, itemPtr, &viewr); // this counts item->numRows
  1490.       if (atline>0) rct.bottom += itemPtr->spaceBefore; 
  1491.       rct.bottom += leadHeight  
  1492.                               + itemPtr->lineHeight * (itemPtr->numRows) 
  1493.                               + itemPtr->spaceAfter;
  1494.            leadHeight = itemPtr->leadHeight;
  1495.           atline += itemPtr->numRows;
  1496.             }
  1497.         itemNum++;
  1498.         }
  1499.  
  1500.     fSelRect= rct;  
  1501.     //MapView2Doc( fSelRect);
  1502.     fSelInPict= false; //!! check if selrect is in a picture !!
  1503.     fSelParag= 1;     // parag # are +1 from MapPoint !!
  1504.     fSelChar= 0;      
  1505.     fSelEndParag= fNumItems;         // parag # are +1 of item# from MapPoint !!
  1506.     fSelEndChar= 0;       
  1507.     fSelected= (fSelParag > 0 && fSelEndParag > 0);
  1508.     HiliteSelection(fSelected);
  1509. }
  1510.  
  1511.  
  1512. void DRichView::MarkSelection( Nlm_RecT selrect)
  1513. {
  1514.     Nlm_PoinT pt;
  1515.     short            row, parag;
  1516.     Nlm_RecT    arect;
  1517.     char            word[50];
  1518.     
  1519.     ClearSelection(); // clear any old sel -- i.e., wipe view markings
  1520.     fSelRect= selrect; // ?? don't we need to map selrect in view coords to doc coords !?
  1521.     MapView2Doc( fSelRect);
  1522.     fSelInPict= false; //!! check if selrect is in a picture !!
  1523.  
  1524.     pt.x= selrect.left;
  1525.     pt.y= selrect.top;
  1526.     MapPoint( pt, parag, row, &arect, word, 40, &fSelStyle);
  1527.     fSelParag= parag;     // parag # are +1 from MapPoint !!
  1528.     fSelChar= gMapOfs;     // dang global... fix mappoint to return it!
  1529.                         // fSelChar was correct
  1530.     if (fSelStyle.ispict) {
  1531.         fSelInPict= true;
  1532.             // ??? must make fSelRect relative to pict frame
  1533.         //fSelRect.left -= fDrawr.left;
  1534.         //fSelRect.right -= fDrawr.left;
  1535.         //fSelRect.top -= fDrawr.top;
  1536.         //fSelRect.bottom -= fDrawr.top;
  1537.         fSelEndParag= 0;
  1538.         fSelEndChar= 0;
  1539.         fSelected= (fSelParag > 0);
  1540.         }
  1541.     else {    
  1542.         pt.x= selrect.right;
  1543.         pt.y= selrect.bottom;
  1544.         MapPoint( pt, parag, row, &arect, word, 40, NULL);
  1545.         fSelEndParag= parag;         // parag # are +1 of item# from MapPoint !!
  1546.         fSelEndChar= gMapOfs;      // fSelEndChar is too large ???
  1547.         fSelected= (fSelParag > 0 && fSelEndParag > 0);
  1548.         }
  1549.     HiliteSelection(fSelected);
  1550. }
  1551.  
  1552.  
  1553. Boolean DRichView::GetSelection( Boolean& inpict,
  1554.                     short& selparag, short& selchar, 
  1555.                     short& selendparag, short& selendchar,
  1556.                     Nlm_RecT& selrect, DRichStyle* selstyle)
  1557. {
  1558.     inpict= fSelInPict;
  1559.     selparag= fSelParag - 1; // !!!!!! FIX DAMN +1 used above !!!!!!
  1560.     selchar= fSelChar;
  1561.     selendparag= fSelEndParag - 1; // !!!!!! FIX DAMN +1 used above !!!!!!
  1562.     selendchar= fSelEndChar;
  1563.     selrect= fSelRect; // !? must we map from doc coords to view coords ??
  1564.     if (selstyle) { *selstyle = fSelStyle; } //style at start of selection (for pict !?)
  1565.     return fSelected;
  1566. }
  1567.  
  1568. char* DRichView::GetSelectedText()
  1569. {
  1570.     long startp, endp, startc, endc;
  1571.     char* theText= NULL;
  1572.  
  1573.     if (fSelInPict) {
  1574.         return NULL; // for now, fix to copy pict to system clipboard
  1575.         }
  1576.         
  1577.     if (fSelParag) {
  1578.         // if selection == NULL ?? return all of text ????
  1579.         startp= fSelParag - 1; 
  1580.         endp= fSelEndParag - 1;
  1581.         startc= fSelChar;
  1582.         endc= fSelEndChar;
  1583.         }
  1584.     else {
  1585.         startp= 0; 
  1586.         endp= fNumItems-1;
  1587.         startc= 0;
  1588.         endc= 0;
  1589.         }
  1590.     
  1591.     for (short par= startp; par<= endp; par++) {
  1592.             // need to handle start/end chars ...
  1593.         DParagraph* itemPtr = GetParaPtr( par);
  1594.         if (itemPtr) {
  1595.             Boolean first= (par == startp);
  1596.             Boolean last = (par == endp);
  1597.             char  savec = 0;
  1598.             char* partext= (char*) itemPtr->fDataPtr;
  1599. #if 1
  1600.             if (first) partext += startc;
  1601.             if (last && endc) {
  1602.                 savec= partext[endc+1];
  1603.                 partext[endc+1]= 0;
  1604.                 }
  1605. #endif
  1606.             if (theText) StrExtendCat( &theText, partext);
  1607.             else theText= StrDup( partext);
  1608.             StrExtendCat( &theText, LINEEND); // append newline for each parag ?
  1609.             if (savec) partext[endc+1]= savec;
  1610.             }
  1611.         }
  1612.          
  1613.     return theText;
  1614. }
  1615.  
  1616.  
  1617.  
  1618. short DRichView::UpdateLineStarts(short first)
  1619. {
  1620.             //  Recalculates the first lines as a running sum of the number of rows
  1621.   short     i;
  1622.   DParagraph*  itemPtr;
  1623.   short     totalNumLines;
  1624.  
  1625.   totalNumLines = 0;
  1626.     itemPtr  = GetParaPtr( first);
  1627.   if (itemPtr) totalNumLines = itemPtr->startsAt;
  1628.   for (i = first; i < fNumItems; i++) {
  1629.     itemPtr = GetParaPtr( i);
  1630.     if (itemPtr) {
  1631.       itemPtr->startsAt = totalNumLines;
  1632.       totalNumLines += itemPtr->numRows;
  1633.         }
  1634.       }
  1635.   return totalNumLines;
  1636. }
  1637.  
  1638.  
  1639. void DRichView::CollectRange(short item, short& lowest, short& highest)
  1640. {
  1641.   lowest  = MIN(lowest, item);
  1642.   highest = MAX(highest, item);
  1643. }
  1644.  
  1645.  
  1646.  
  1647. void DRichView::CacheAndFormat(short item, DParagraph* itemPtr, Nlm_RectPtr r)
  1648. {
  1649.                 //  Formats text (for drawing) if the item text is not currently cached
  1650.   if (itemPtr && r && itemPtr->notCached) FormatText(item, itemPtr, TRUE);
  1651. }
  1652.  
  1653. void DRichView::CacheIfNever( short item, DParagraph* itemPtr, Nlm_RectPtr r)
  1654. {
  1655.         //     Formats text (for obtaining the correct number of rows) if the item
  1656.         //     text has never been cached
  1657.   if (itemPtr && r && itemPtr->neverCached) FormatText(item, itemPtr, TRUE);
  1658. }
  1659.  
  1660.  
  1661. void DRichView::FreeCachedItem( short item, short& lowest, short& highest)
  1662. {
  1663.         // Frees the formatted text string for an item that is not currently visible
  1664.   DParagraph*  itemPtr = GetParaPtr( item);
  1665.   if (itemPtr) {
  1666.     itemPtr->fText = (char*) MemFree (itemPtr->fText);
  1667.     itemPtr->notCached = TRUE;
  1668.     if (fIsVirtual && fNumItems > 0) {
  1669.       itemPtr->numRows = 30000 / fNumItems;
  1670.       CollectRange(item, lowest, highest);
  1671.         }
  1672.       }
  1673. }
  1674.  
  1675.  
  1676. short DRichView::VisLinesAbove(Nlm_RectPtr r, short item,
  1677.                            short line, short& lowest, short& highest)
  1678. {
  1679.         //    Returns the number of lines visible on the screen if the given line
  1680.         //    in the given item is the last line visible
  1681.   DParagraph*  itemPtr;
  1682.   short     pixels, vis;
  1683.  
  1684.   vis = 0;
  1685.   if ( r && item < fNumItems) {
  1686.     pixels = r->bottom - r->top;
  1687.     while (pixels > 0 && item >= 0) {
  1688.       itemPtr = GetParaPtr( item);
  1689.       if (itemPtr) {
  1690.         CollectRange( item, lowest, highest);
  1691.         CacheIfNever( item + 1, itemPtr, r);
  1692.         if (line < 0)  line = itemPtr->numRows - 1;
  1693.         while (pixels > 0 && line >= 0 && line < itemPtr->numRows) {
  1694.           pixels -= itemPtr->lineHeight;
  1695.           if (pixels >= 0)  vis++;
  1696.           line--;
  1697.             }
  1698.         pixels -= itemPtr->leadHeight;
  1699.         pixels -= itemPtr->spaceBefore + itemPtr->spaceAfter;
  1700.           }
  1701.       item--;
  1702.         }
  1703.       }
  1704.   return vis;
  1705. }
  1706.  
  1707.  
  1708.  
  1709. short DRichView::VisLinesBelow( Nlm_RectPtr r, short item,
  1710.                                        short line, short& lowest, short& highest)
  1711. {
  1712.         //    Returns the number of lines visible on the screen if the given line
  1713.         //    in the given item is the first line visible
  1714.   DParagraph*  itemPtr;
  1715.   short     pixels, vis;
  1716.  
  1717.   vis = 0;
  1718.   if (r && item < fNumItems && item >= 0) {
  1719.     pixels = r->bottom - r->top;
  1720.     while (pixels > 0 && item < fNumItems) {
  1721.       itemPtr = GetParaPtr( item);
  1722.       if (itemPtr) {
  1723.         CollectRange(item, lowest, highest);
  1724.         CacheIfNever(item + 1, itemPtr, r);
  1725.         if (line  < 0) {
  1726.           line = 0;
  1727.           pixels -= itemPtr->leadHeight;
  1728.             pixels -= itemPtr->spaceBefore + itemPtr->spaceAfter;
  1729.             }
  1730.         while (pixels > 0 && line >= 0 && line < itemPtr->numRows) {
  1731.           pixels -= itemPtr->lineHeight;
  1732.           if (pixels >= 0) vis++;
  1733.           line++;
  1734.             }
  1735.         line = -1;
  1736.           }
  1737.       item++;
  1738.         }
  1739.       }
  1740.   return vis;
  1741. }
  1742.  
  1743.  
  1744.  
  1745. short DRichView::PixelsBetween( Nlm_RectPtr r, short firstLine,
  1746.                            short lastLine, short& lowest, short& highest)
  1747. {
  1748.              //   Returns the number of pixels between two lines
  1749.      short     count;
  1750.   short     item;
  1751.   DParagraph*  itemPtr;
  1752.   short     line;
  1753.   short     numLines;
  1754.   short     onItem;
  1755.   short     pixels;
  1756.  
  1757.   pixels = 0;
  1758.   if ( r ) {
  1759.       // dgg -- are these line no.s off by one??  came from Scroll()
  1760.       // firstLine--; lastLine--;
  1761.     count = ABS (lastLine - firstLine);
  1762.     item = GetItemNum( MIN (firstLine, lastLine));
  1763.     itemPtr = GetParaPtr( item);
  1764.     onItem = item;
  1765.     if (itemPtr != NULL && item >= 0) {
  1766.       CollectRange( item, lowest, highest);
  1767.       CacheIfNever( item + 1, itemPtr, r);
  1768.       line = MIN (firstLine, lastLine) - itemPtr->startsAt;
  1769.       while (count > 0 && item < fNumItems) {
  1770.         if (item != onItem) {
  1771.           itemPtr = GetParaPtr( item);
  1772.           onItem = item;
  1773.             }
  1774.         if ( itemPtr ) {
  1775.           CollectRange (item, lowest, highest);
  1776.           CacheIfNever ( item + 1, itemPtr, r);
  1777.           numLines = itemPtr->numRows;
  1778. #if 1
  1779.                     if (line == 0) pixels += itemPtr->spaceBefore;
  1780.                     if (MAX(firstLine,lastLine) >= numLines + itemPtr->startsAt)
  1781.                         pixels += itemPtr->spaceAfter;
  1782. #else
  1783.         // ?? old here is bad -- don't do spaceBefore unless this is 1st line in parag
  1784.         // likewise spaceafter if this is last
  1785.                 pixels += itemPtr->spaceBefore + itemPtr->spaceAfter;  
  1786. #endif
  1787.           while (count > 0 && line >= 0 && line < numLines) {
  1788.             pixels += itemPtr->lineHeight;
  1789.             line++;
  1790.             count--;
  1791.               }
  1792.             }
  1793.         item++;
  1794.         if (line >= numLines) {
  1795.           itemPtr = GetParaPtr( item);
  1796.           onItem = item;
  1797.           if (itemPtr != NULL) {
  1798.             CollectRange (item, lowest, highest);
  1799.             CacheIfNever ( item + 1, itemPtr, r);
  1800.             pixels += itemPtr->leadHeight;
  1801.               }
  1802.             }
  1803.         line = 0;
  1804.           }
  1805.       if (lastLine < firstLine)  pixels = -pixels;
  1806.         }
  1807.       }
  1808.   return pixels;
  1809. }
  1810.  
  1811.  
  1812.  
  1813. void DRichView::Draw()
  1814. {
  1815.             //    Panel callback that traverses the item list and draws visible items
  1816.             //    Clipping is to the intersection of the Nlm_updateRgn (the portion of the
  1817.             //    panel exposed) and the inset area of the document, leaving a four-
  1818.             //    pixel margin
  1819.  
  1820.   Nlm_RegioN   dst;
  1821.   DParagraph*  itemPtr;
  1822.   short          firstLine, highest, item, lowest, off, pixels;
  1823.   Nlm_RecT     r, rct;
  1824.   Nlm_BaR      sb;
  1825.   Nlm_RegioN   src;
  1826.  
  1827.   if (fNumItems > 0) {
  1828. //Debug("DRichView::Draw\n");
  1829.         ViewRect( r);
  1830.     sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  1831.         if (sb) off = Nlm_GetValue(sb);
  1832.         else off= 0;
  1833.     src = Nlm_CreateRgn ();
  1834.     dst = Nlm_CreateRgn ();
  1835.     Nlm_LoadRectRgn (src, r.left, r.top, r.right, r.bottom);
  1836.     Nlm_SectRgn (src, Nlm_updateRgn, dst);
  1837.     Nlm_ClipRgn (dst);
  1838.     Nlm_DestroyRgn (src);
  1839.     Nlm_DestroyRgn (dst);
  1840.     pixels = 0;
  1841.     lowest = 30000; //INT2_MAX; // change for mswin - need??
  1842.         highest = -10000; //INT2_MIN;
  1843.     item = GetItemNum( off);
  1844.     itemPtr = GetParaPtr( item);
  1845.     if (itemPtr) {
  1846.       firstLine = off - itemPtr->startsAt;
  1847.       do {
  1848.         if (itemPtr) {
  1849.           if (itemPtr->neverCached)  CollectRange(item, lowest, highest);
  1850.           CacheAndFormat( item+1, itemPtr, &r);
  1851.           if (pixels != 0)  r.top += itemPtr->leadHeight;
  1852.                   if (firstLine == 0) r.top += itemPtr->spaceBefore;
  1853.           rct = r;
  1854.           rct.bottom = rct.top + itemPtr->lineHeight * (itemPtr->numRows - firstLine);
  1855.           Boolean inrgn= (Nlm_updateRgn == NULL || Nlm_RectInRgn (&rct, Nlm_updateRgn));
  1856.           if (inrgn) {
  1857. //Debug(".");
  1858.             pixels = DrawStyledItem( itemPtr, &r, item+1, firstLine, FALSE, NULL);
  1859.               } 
  1860.           else  
  1861.             pixels = rct.bottom - rct.top;
  1862.            
  1863.           r.top += pixels;
  1864.                   r.top += itemPtr->spaceAfter;
  1865.             }
  1866.         item++;
  1867.         firstLine = 0;
  1868.         itemPtr = GetParaPtr( item);
  1869.       } while (r.top < r.bottom && item < fNumItems);
  1870.       if (lowest < INT2_MAX) 
  1871.         fNumLines = UpdateLineStarts( lowest);
  1872.      
  1873.     }
  1874.     Nlm_ResetClip ();
  1875.      
  1876.   }
  1877.     Nlm_SelectFont(Nlm_programFont);  //Nlm_systemFont
  1878. //Debug("DRichView::Draw done\n");
  1879. }
  1880.  
  1881.  
  1882.  
  1883.  
  1884.  
  1885.  
  1886.  
  1887.  
  1888. void  DRichView::AdjustScroll() 
  1889. {
  1890.             // Calculates an estimate for the scroll bar maximum
  1891.   short     barmax,barval,firstShown,highest, item;
  1892.   short     line,lineInto,lowest;
  1893.   short     pgDn, pgUp, vis;
  1894.   DParagraph*  itemPtr;
  1895.   Nlm_RecT     r;
  1896.   Nlm_BaR      sb;
  1897.  
  1898.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  1899.   if (sb) {
  1900.     if (fNumLines > 0 && fNumItems > 0) {
  1901.           Nlm_SelectFont(Nlm_programFont);  //Nlm_systemFont
  1902.             ViewRect( r);
  1903.       barval = Nlm_GetValue (sb);
  1904.       item = GetItemNum ( barval);
  1905.       line = barval - GetLineStart( item);
  1906.       firstShown = item;
  1907.       lineInto = line;
  1908.       lowest = INT2_MAX;
  1909.       highest = INT2_MIN;
  1910.       itemPtr = GetParaPtr(fNumItems - 1);
  1911.       if (itemPtr) 
  1912.         vis = VisLinesAbove ( &r, fNumItems - 1,
  1913.                              itemPtr->numRows - 1, lowest, highest);
  1914.       pgUp = VisLinesAbove ( &r, item, line, lowest, highest) - 1;
  1915.       pgDn = VisLinesBelow ( &r, item, line, lowest, highest) - 1;
  1916.       if (pgDn < 1) pgDn = 1;
  1917.       if (pgUp < 1) pgUp = 1;
  1918.       if (lowest < INT2_MAX) 
  1919.         fNumLines = UpdateLineStarts( lowest);
  1920.       
  1921.       itemPtr = GetParaPtr(fNumItems - 1);
  1922.       if (itemPtr) {
  1923.         barmax = 0;
  1924.               ViewRect( r);
  1925.         lowest = INT2_MAX;
  1926.         highest = INT2_MIN;
  1927.         vis = VisLinesAbove ( &r, fNumItems - 1,
  1928.                              itemPtr->numRows - 1, lowest,  highest);
  1929.         if (lowest < INT2_MAX) 
  1930.           fNumLines = UpdateLineStarts ( lowest);
  1931.          
  1932.         barmax = fNumLines - vis;
  1933.         barval = GetLineStart(firstShown) + lineInto;
  1934.         Nlm_CorrectBarPage (sb, pgUp, pgDn);
  1935.         if (barval > fBarmax) {
  1936.           Nlm_CorrectBarMax (sb, barmax);
  1937.           Nlm_CorrectBarValue (sb, barval);
  1938.             } 
  1939.         else {
  1940.           Nlm_CorrectBarValue (sb, barval);
  1941.           Nlm_CorrectBarMax (sb, barmax);
  1942.             }
  1943.         fBarmax = barmax;
  1944.           }
  1945.         } 
  1946.     else  
  1947.       Nlm_Reset (sb);
  1948.       }
  1949. }
  1950.  
  1951.  
  1952.  
  1953.  
  1954.  
  1955.  
  1956. void  DRichView::UpdateItemHeights(DParagraph* aParag)
  1957. {
  1958.             // Returns the maximum height of all fonts used in an item
  1959.   short         i, linhgt,maxhgt;
  1960.  
  1961.   if (aParag) {
  1962.     maxhgt = 0;
  1963.     i = aParag->fNumStyles;
  1964.     while (i > 0) {
  1965.       i--;
  1966.       DRichStyle* st= GetStyleAtIndex(aParag, i);
  1967.            linhgt = GetFontHeight(st->font) + abs(st->superSub); 
  1968.       if (st->ispict) 
  1969.                  linhgt = MAX(linhgt, st->pixheight + 2); // +2 for leading !?
  1970.       if (linhgt > maxhgt) maxhgt = linhgt;
  1971.         }
  1972.     if (maxhgt == 0)  maxhgt = Nlm_stdLineHeight;
  1973.     aParag->lineHeight = MAX(maxhgt, aParag->minHeight);
  1974.     if ( aParag->openSpace)  
  1975.       aParag->leadHeight = maxhgt;
  1976.     else 
  1977.       aParag->leadHeight = 0;
  1978.       }
  1979. }
  1980.  
  1981.  
  1982. short DRichView::SkipPastNewLine(char* text, short cnt)
  1983. {
  1984.   char  ch;
  1985.   ch = *(text + cnt);
  1986.   while (ch != '\0' && ch != '\n' && cnt < 16380) {
  1987.     cnt++;
  1988.     ch = *(text + cnt);
  1989.       }
  1990.   while ((ch == '\n' || ch == '\r') && cnt < 16380) {
  1991.     cnt++;
  1992.     ch = *(text + cnt);
  1993.       }
  1994.   return cnt;
  1995. }
  1996.  
  1997. void     DRichView::HandleAddInsRep( handleMode mode, short item, char* text, 
  1998.                     DParagraph* parFormat, DRichStyle* styles, short nstyles, Nlm_FonT aFont) 
  1999. {
  2000.     DRichStyle    * aStyle = NULL;
  2001.   DParagraph     * para = NULL;
  2002.     
  2003.     if (!parFormat) {
  2004.         para= new DParagraph();
  2005.         parFormat= para;
  2006.         }
  2007.     
  2008.     if (!styles) {
  2009.         aStyle= new DRichStyle();
  2010.         if (aFont) aStyle->font= aFont;
  2011.         aStyle->last= true;
  2012.         styles= aStyle;
  2013.         nstyles= 1;
  2014.         }
  2015.         
  2016.     if (text && *text != '\0') {
  2017.       long start = 0;
  2018.       short atstyle= 0;
  2019.       long cntr = StringLen (text);
  2020.       long cnt = MIN (cntr, 16000);
  2021.       cnt = SkipPastNewLine (text + start, cnt);
  2022.       while (cnt > 0) {
  2023.         char* txt = (char*) MemNew(cnt + 1);
  2024.         MemCopy(txt, text + start, cnt);
  2025.         
  2026.         // damn !!! have to fiddle w/ styles[...].nextofs for this newline cutting stuff !!
  2027.         short ist= atstyle, nst= 0;
  2028.         if (nstyles) {
  2029.             do ist++; 
  2030.             while (ist<nstyles && styles[ist].nextofs <= start + cnt);
  2031.             nst= ist - atstyle;     
  2032.             }
  2033.             
  2034.         switch (mode) {
  2035.             case kAppend: 
  2036.                 Append( txt, (cnt / 50) + 1, parFormat, &styles[atstyle], nst, true);
  2037.                 break;
  2038.             case kReplace:
  2039.                     Replace( item, txt, (cnt / 50) + 1, parFormat, &styles[atstyle], nst, true);
  2040.                 break;
  2041.             case kInsert:
  2042.                     Insert( item, txt, (cnt / 50) + 1, parFormat, &styles[atstyle], nst, true);
  2043.                 break;
  2044.             }
  2045.             
  2046.         atstyle += nst - 1;
  2047.         start += cnt;
  2048.         cntr -= cnt;
  2049.         cnt = MIN (cntr, 16000);
  2050.         cnt = SkipPastNewLine (text + start, cnt);
  2051.           }
  2052.         } 
  2053.     else switch (mode) {
  2054.       case kAppend: 
  2055.             Append( "", 1, parFormat, styles, nstyles, false);
  2056.           break;
  2057.       case kReplace:
  2058.             Replace( item, "", 1, parFormat, styles, nstyles, false);
  2059.           break;
  2060.         case kInsert:
  2061.             Insert( item, "", 1, parFormat, styles, nstyles, false);
  2062.           break;
  2063.       }
  2064.       
  2065.   if (para) delete para;
  2066.   //if (aStyle) delete aStyle;
  2067. }
  2068.  
  2069.  
  2070. void     DRichView::Append( char* text, DParagraph* parFormat, DRichStyle* styles, 
  2071.                     short nstyles, Nlm_FonT aFont) 
  2072. {
  2073.     HandleAddInsRep( kAppend, 0,  text, parFormat, styles, nstyles, aFont);
  2074. }
  2075.  
  2076. void     DRichView::Replace( short item, char* text, DParagraph* parFormat, 
  2077.                                 DRichStyle* styles, short nstyles, Nlm_FonT aFont) 
  2078. {
  2079.     HandleAddInsRep( kReplace, item, text, parFormat, styles, nstyles, aFont);
  2080. }
  2081.  
  2082. void     DRichView::Insert( short item, char* text, DParagraph* parFormat,
  2083.              DRichStyle* styles, short nstyles, Nlm_FonT aFont) 
  2084. {
  2085.     HandleAddInsRep( kInsert, item, text, parFormat, styles, nstyles, aFont);
  2086. }
  2087.  
  2088.  
  2089.  
  2090. void  DRichView::Delete( short item) 
  2091. {
  2092.                 //  Deletes an item from a document
  2093.   if (item >= 0 && item < fNumItems) {
  2094.         fParags->AtDelete(item);
  2095.     fNumItems = fParags->GetSize(); 
  2096.     fNumLines = UpdateLineStarts( item);
  2097.     if (fAutoAdjust) AdjustScroll();
  2098.     }
  2099. }
  2100.  
  2101.  
  2102. void  DRichView::GetDocStats( short& numParags, short& numLines) 
  2103. {
  2104.   numParags = fNumItems;
  2105.   numLines = fNumLines;  
  2106. }
  2107.  
  2108.  
  2109.  
  2110. void  DRichView::GetItemStats( short item, short& startsAt, short& numRows, 
  2111.                                                              short& lineHeight) 
  2112. {
  2113.     DParagraph* itemPtr = GetParaPtr( item );  // item starts at 0
  2114.   if (itemPtr) {
  2115.     startsAt = itemPtr->startsAt;
  2116.     numRows = itemPtr->numRows;
  2117.     lineHeight = itemPtr->lineHeight;
  2118.       }
  2119.   else {
  2120.       startsAt = 0;
  2121.       numRows = 0;
  2122.       lineHeight = 0;  
  2123.       }
  2124. }
  2125.  
  2126.  
  2127.  
  2128.  
  2129.  
  2130. void     DRichView::MapPoint( Nlm_PoinT pt, short& item, short& row, Nlm_RectPtr rct,
  2131.                     char* wordAt, short maxword, DRichStyle* styleAt) 
  2132. {
  2133.                 // Converts a mouse point to a item, row positions  within a document
  2134.   short     cl,firstItem,firstLine;
  2135.   short     itemNum,rw,itm,leadHeight,lineHeight,numRows,off;
  2136.   Boolean      goOn;
  2137.   Nlm_RecT     viewr, paragr, rc;
  2138.   Nlm_BaR      sb;
  2139.   DParagraph*  itemPtr;
  2140.  
  2141.   itm = 0;
  2142.   rw = 0;
  2143.   cl = 0;
  2144.   Nlm_LoadRect (&rc, 0, 0, 0, 0);
  2145.  
  2146.     ViewRect( viewr);
  2147.   if (Nlm_PtInRect (pt, &viewr)) {
  2148.     sb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) fPanel);
  2149.         if (sb) off = Nlm_GetValue(sb);
  2150.         else off= 0;
  2151.     goOn = TRUE;
  2152.     itemNum = GetItemNum( off);
  2153.     itemPtr = GetParaPtr( itemNum);
  2154.     if (itemPtr) {
  2155.             paragr= viewr;
  2156.       firstLine = off - itemPtr->startsAt;
  2157.       firstItem = itemNum;
  2158.       while (goOn && itemNum < fNumItems) {
  2159.         itemPtr = GetParaPtr( itemNum);
  2160.         if (itemPtr) {
  2161.           CacheIfNever( itemNum + 1, itemPtr, ¶gr);
  2162.           if (itemNum > firstItem)  
  2163.             leadHeight = itemPtr->leadHeight;
  2164.             else 
  2165.             leadHeight = 0;
  2166.           if (firstLine==0) paragr.top += itemPtr->spaceBefore;
  2167.        
  2168.           lineHeight = itemPtr->lineHeight;
  2169.           numRows = MIN (itemPtr->numRows - firstLine,
  2170.                          MAX ((viewr.bottom - paragr.top - leadHeight) / lineHeight, 1));
  2171.           paragr.bottom = paragr.top + leadHeight + lineHeight * numRows;
  2172.                paragr.bottom += itemPtr->spaceAfter;
  2173.                
  2174.              if (Nlm_PtInRect(pt, ¶gr) && numRows > 0) {
  2175.             goOn = FALSE;
  2176.             itm = itemNum + 1;
  2177.             if (pt.y <= paragr.top + leadHeight)  
  2178.               rw = 0;
  2179.             else  
  2180.               rw = firstLine + ((pt.y - paragr.top - leadHeight) / lineHeight) + 1;
  2181.  
  2182.               rc = paragr;
  2183.               if (rw) rc.top += (rw-1) * lineHeight;
  2184.               rc.bottom = rc.top + lineHeight;
  2185.               
  2186.             // dgg -- map to style section                 
  2187.             if (wordAt || styleAt) {
  2188.                       short textofs = DrawStyledItem( itemPtr, ¶gr, itm/*itemNum+1*/, 
  2189.                                                   firstLine/*rw*/, FALSE, &pt);
  2190.                             if (wordAt) {
  2191.                                 if (textofs<0) {
  2192.                                     StrNCpy(wordAt, "**not found", maxword);
  2193.                          wordAt[maxword-1]= 0;
  2194.                                     }
  2195.                                 else {
  2196.                                     char *cbase= itemPtr->fText;
  2197.                                     char *cstart= cbase + textofs;
  2198.                                     if (*cstart <= ' ') {
  2199.                                         if (cstart[1] > ' ') cstart++;
  2200.                                         else if (cstart[-1] > ' ') cstart--;
  2201.                                         }
  2202.                                     char *cend= cstart;
  2203.                        while (cstart > cbase && cstart[-1] > ' ') cstart--;
  2204.                           while (*cend > ' ') cend++;
  2205.                        short len= MAX(1, MIN( maxword-1, cend - cstart));
  2206.                          StrNCpy(wordAt, cstart, len);
  2207.                          wordAt[len]= 0;
  2208.                          }
  2209.                        }
  2210.               if (styleAt && fMapStyle) {
  2211.                   *styleAt= *fMapStyle; // GetStyleAtChar( itemPtr, textofs);
  2212.                   }
  2213.                    }
  2214.                    
  2215.               } 
  2216.           else  
  2217.             paragr.top = paragr.bottom;
  2218.            
  2219.           if (numRows < itemPtr->numRows - firstLine)  
  2220.             goOn = FALSE;
  2221.             }
  2222.         itemNum++;
  2223.         firstLine = 0;
  2224.         }
  2225.       }
  2226.     }
  2227.  
  2228.     item = itm;
  2229.     row = rw;
  2230.     if (rct) *rct = rc;
  2231. }
  2232.  
  2233.  
  2234.  
  2235.  
  2236. Boolean DRichView::Find( char* match, short& itemat, short& charat,
  2237.                             short startitem, short startchar, Boolean caseSensitive) 
  2238. {
  2239.   DParagraph*        itemPtr;
  2240.   short            i, stop;
  2241.     
  2242.   if (match) {
  2243.         char* tempmatch= StrDup( match);
  2244.     if (fNumItems > 0) {
  2245.           stop = fNumItems;
  2246.         if (startitem < 0) startitem = 0;
  2247.         for (i = startitem; i < stop; i++) {
  2248.           itemPtr = GetParaPtr( i);
  2249.           if (itemPtr) {
  2250.                          char* text;
  2251.                         text= (char*) itemPtr->fDataPtr;
  2252.             if (text) {
  2253.                             Nlm_Uint4        foundat;
  2254.                             Boolean         found 
  2255.                                     = Nlm_StrngPos(text, tempmatch, startchar, caseSensitive, &foundat);
  2256.               if (found) {
  2257.                   itemat= i;
  2258.                     charat= foundat;
  2259.                                 MemFree( tempmatch);
  2260.                   return TRUE;
  2261.                   }      
  2262.                   }
  2263.               }
  2264.           startchar= 0; // ! zero it !! or we miss others ! 
  2265.           }
  2266.                 }
  2267.         MemFree( tempmatch);
  2268.         }
  2269.     return FALSE;
  2270. }
  2271.  
  2272.  
  2273.  
  2274.  
  2275. Boolean     DRichView::FindURL(short& itemat, short& charat, short& charlen,
  2276.                                                         short startitem, short startchar) 
  2277. {
  2278.   DParagraph*     itemPtr;
  2279.   short            i, stop;
  2280.     
  2281.     if (fNumItems > 0) {
  2282.       stop = fNumItems;
  2283.     if (startitem < 0) startitem = 0;
  2284.     for (i = startitem; i < stop; i++) {
  2285.       itemPtr = GetParaPtr( i);
  2286.       if (itemPtr) {
  2287.                 char* text;
  2288.                 // text= (char*) itemPtr->fDataPtr; << this is bad, need fText !
  2289.                 FormatText( i, itemPtr, TRUE);
  2290.                 text = itemPtr->fText;
  2291.           if (text) {
  2292.                     char             *cp, *ep;
  2293.  
  2294.                     for (cp= text+startchar+3; *cp; cp++) { 
  2295.                         if (*cp == ':') {
  2296.                             if ( (cp[1] == '/' && cp[2] == '/') 
  2297.                                 || (0 == Nlm_StringNICmp( MAX(text, cp-6), "mailto", 6))
  2298.                                 || (0 == Nlm_StringNICmp( MAX(text, cp-4), "news", 4))
  2299.                                 /* ^^^^ Should use DURL::IsURL(cp) !! */
  2300.                                 ) {
  2301.                                   cp--;
  2302.                                     while (isalnum(*cp) && cp>text) cp--;
  2303.                                     if (*cp == '"') ep= strchr(cp+1,'"');
  2304.                                     else if (*cp == '\'') ep= strchr(cp+1,'\'');
  2305.                                     else if (*cp == '<') ep= strchr(cp+1,'>');
  2306.                                     else if (*cp == '=' 
  2307.                                         && 0 == Nlm_StringNICmp( MAX(text,cp-4), "href=", 4 )) 
  2308.                                             ep= strchr(cp+1,'>');
  2309.                                     else ep= NULL;
  2310.                                     if (!isalnum(*cp)) cp++;
  2311.                                   if (ep == NULL) for (ep=cp; isgraph(*ep); ep++) ;
  2312.                       itemat= i;
  2313.                       charat= cp - text;
  2314.                                     charlen= ep ? ep - cp : 0;
  2315.                       return TRUE;
  2316.                       }
  2317.                             } 
  2318.                         }     
  2319.               }
  2320.           }
  2321.       startchar= 0; // ! zero it !! or we miss others ! 
  2322.       }
  2323.         }
  2324.  
  2325.     return FALSE;
  2326. }
  2327.  
  2328.  
  2329.  
  2330.  
  2331.  
  2332. void     DRichView::InsertStyle( short atitem, short atchar, short atlength, 
  2333.                                                             DRichStyle* theStyle)
  2334. {
  2335.   DParagraph*     itemPtr;
  2336.     short                    numStyles;
  2337.     
  2338.     itemPtr = GetParaPtr( atitem);
  2339.   if (theStyle && itemPtr) {
  2340.         short ist, jst;
  2341.         numStyles= itemPtr->fNumStyles;
  2342.         StyleIndex* si = itemPtr->fStyleIndex;
  2343.         short newofs= atchar + atlength;
  2344.         short newnum= numStyles + 2;
  2345.         StyleIndex* sinew=    
  2346.             (StyleIndex*) MemNew( newnum*sizeof(StyleIndex)); 
  2347.  
  2348.         short styleid= FindOrAddStyle(theStyle);
  2349.         Boolean notat= true, notnew= true;
  2350.         for (ist=0, jst= 0; ist<numStyles && jst<newnum; ist++) {
  2351.             short ofs= si[ist].nextofs;
  2352.             
  2353.             if (atchar <= ofs && notat) {
  2354.                 if (atchar < ofs) {
  2355.                     sinew[jst]= si[ist];
  2356.                     sinew[jst].nextofs= atchar;
  2357.                     if (jst<newnum) jst++;
  2358.                     }
  2359.                 else {
  2360.                     sinew[jst]= si[ist];
  2361.                     if (jst<newnum) jst++;
  2362.                     }
  2363.                 sinew[jst].nextofs= newofs;
  2364.                 sinew[jst].styleid= styleid;
  2365.                 if (jst<newnum) jst++;
  2366.                 notat= false;
  2367.                 }
  2368.             else {  // atchar > ofs
  2369.                 sinew[jst]= si[ist];
  2370.                 if (jst<newnum) jst++;
  2371.                 }
  2372.             
  2373.             if (newofs <= ofs && notnew) {
  2374.                 sinew[jst]= si[ist];
  2375.                 if (jst<newnum) jst++;
  2376.                 notnew= false;
  2377.                 }
  2378.             }
  2379.             
  2380.         itemPtr->fStyleIndex= sinew;
  2381.         itemPtr->fNumStyles = jst; // newnum
  2382.         MemFree( si);
  2383.         
  2384.         
  2385.       }
  2386.      
  2387. }
  2388.  
  2389.  
  2390.  
  2391.  
  2392.  
  2393.  
  2394.  
  2395. char* DRichView::GetText(short item, short row) 
  2396. {
  2397.             //   Returns a string with text from a document.  If item, row
  2398.             //   parameters are 0, text is taken from any item, row,
  2399.             //   respectively.  The string must be freed by the application
  2400.   ByteStorePtr      bsp;
  2401.   char              ch;
  2402.   short              cl, i;
  2403.   short              k, num;
  2404.   short              rw, start, stop;
  2405.   char                    * text;
  2406.   char                    * ptr;
  2407.   Nlm_RecT            r;
  2408.   DParagraph*        itemPtr;
  2409.  
  2410.   text = NULL;
  2411.   if (item >= 0) {
  2412.         ViewRect( r);
  2413.     if (fNumItems > 0) {
  2414.       bsp = BSNew (0);
  2415.       if (bsp != NULL) {
  2416.         if (item == 0) {
  2417.           start = 0;
  2418.           stop = fNumItems;
  2419.             } 
  2420.         else if (item <= fNumItems) {
  2421.           start = item - 1;
  2422.           stop = item;
  2423.             } 
  2424.         else {
  2425.           start = 0;
  2426.           stop = 0;
  2427.             }
  2428.  
  2429. #if 1
  2430.             if (row < 0) {
  2431.         itemPtr = GetParaPtr( start);
  2432.         if (itemPtr) {
  2433.                     text= (char*) itemPtr->fDataPtr;
  2434.                       // if (text) text= MemDup(text);   //!? caller expects to own this data !? 
  2435.                     }
  2436.                 return text;
  2437.                 }
  2438. #else
  2439.             if (row < 0) {
  2440.         for (i = start; i < stop; i++) {
  2441.           itemPtr = GetParaPtr( i);
  2442.           if (itemPtr) {
  2443.                       if (!text) text = DataToChar(itemPtr->fDataPtr);
  2444.                         }
  2445.                     }
  2446.                   return text;
  2447.                 }
  2448. #endif
  2449.  
  2450.         for (i = start; i < stop; i++) {
  2451.           itemPtr = GetParaPtr( i);
  2452.           if (itemPtr) {
  2453.                         DParagraph itemData( itemPtr->fDataPtr, false, itemPtr->numRows, itemPtr, 
  2454.                                                 itemPtr->fStyleIndex, itemPtr->fNumStyles, false);
  2455.             FormatText(i, &itemData, TRUE);
  2456.             text = itemData.fText;
  2457.             if (text && *text != '\0') {
  2458.               if (i > start && itemPtr->openSpace > 0 && item == 0) 
  2459.                 BSPutByte (bsp, (short) '\n');
  2460.               rw = 0;
  2461.               cl = 0;
  2462.               ptr = text;
  2463.               ch = *ptr;
  2464.               while (ch != '\0') {
  2465.                 if (ch == '\n') {
  2466.                   if ((rw + 1 == row) || row == 0)  
  2467.                     BSPutByte (bsp, (short) '\n');
  2468.                   cl = 0;
  2469.                   rw++;
  2470.                   ptr++;
  2471.                     } 
  2472.                 else if (ch == '\t') {
  2473.                   if ((rw + 1 == row || row == 0)) 
  2474.                     BSPutByte (bsp, (short) '\t');
  2475.                    
  2476.                   cl++;
  2477.                   ptr++;
  2478.                     } 
  2479.                 else {
  2480.                   num = 0;
  2481.                   while (ch != '\0' && ch != '\t' && ch != '\n') {
  2482.                     num++;
  2483.                     ch = ptr [num];
  2484.                       }
  2485.                   if (num > 0  &&
  2486.                       (rw + 1 == row || row == 0)) {
  2487.                     for (k = 0; k < num; k++) 
  2488.                       BSPutByte (bsp, (short) ptr [k]);
  2489.                     }
  2490.                   ptr += num;
  2491.                     }
  2492.                 ch = *ptr;
  2493.                   }
  2494.                 }
  2495.               }
  2496.             }
  2497.         text = (char*) BSMerge (bsp, NULL);
  2498.         BSFree (bsp);
  2499.           }
  2500.         }
  2501.       }
  2502.   return text;
  2503. }
  2504.  
  2505.  
  2506.  
  2507.  
  2508.  
  2509. Boolean    DRichView::IsVisible( short item, short& top, short& bottom, short& firstline) 
  2510. {
  2511.             // Finds the visible region of an item in a document
  2512.   short             firstItem, fstLine, itemNum, leadHeight,lineHeight, numRows,off;
  2513.   Nlm_RecT         r, rct;
  2514.   Boolean              goOn, rsult;
  2515.   Nlm_BaR          sb;
  2516.   DParagraph*      itemPtr;
  2517.  
  2518.   rsult = FALSE;
  2519.      top = 0;
  2520.      bottom = 0;
  2521.   firstline = 0;
  2522.  
  2523.     ViewRect(  r);
  2524.   sb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) fPanel);
  2525.   if (sb) off = Nlm_GetValue (sb);
  2526.   else off= 0;
  2527.   if (item > 0 && item <= fNumItems) {
  2528.     item--;
  2529.     goOn = TRUE;
  2530.     Nlm_LoadRect (&rct, r.left, r.top, r.right, r.top);
  2531.     itemNum = GetItemNum ( off);
  2532.     itemPtr = GetParaPtr( itemNum);
  2533.     if (itemPtr) {
  2534.       fstLine = off - itemPtr->startsAt;
  2535.       firstItem = itemNum;
  2536.       lineHeight = 0;
  2537.       leadHeight = 0;
  2538.       numRows = 0;
  2539.       while (goOn && itemNum < fNumItems && itemNum <= item) {
  2540.         itemPtr = GetParaPtr( itemNum);
  2541.         if (itemPtr ) {
  2542.           CacheIfNever ( itemNum + 1, itemPtr, &r);
  2543.           if (itemNum > firstItem)  
  2544.             leadHeight = itemPtr->leadHeight;
  2545.             else  
  2546.             leadHeight = 0;
  2547.               if (fstLine==0) rct.top += itemPtr->spaceBefore;
  2548.           
  2549.           lineHeight = itemPtr->lineHeight;
  2550.           rct.top += leadHeight;
  2551.           numRows = MIN (itemPtr->numRows,
  2552.                          MAX ((r.bottom - rct.top) / lineHeight, 0));
  2553.           rct.bottom = rct.top + lineHeight * (numRows - fstLine);
  2554.               rct.bottom += itemPtr->spaceAfter;
  2555.           if (itemNum == item) {
  2556.             goOn = FALSE;
  2557.             if (numRows > 0) {
  2558.                 top = rct.top;
  2559.                 bottom = rct.bottom;
  2560.                 firstline = fstLine;
  2561.               rsult = TRUE;
  2562.                 }
  2563.               } 
  2564.           else  
  2565.             rct.top = rct.bottom;
  2566.           if (numRows < itemPtr->numRows)  
  2567.             goOn = FALSE;
  2568.             }
  2569.         itemNum++;
  2570.         fstLine = 0;
  2571.           }
  2572.         }
  2573.       }
  2574.   
  2575.   return rsult;
  2576. }
  2577.  
  2578.  
  2579.  
  2580.  
  2581.  
  2582. Boolean DRichView::GetScrollStats( short& offset, short& firstShown, short& firstLine) 
  2583. {
  2584.   short     item, line,off;
  2585.   Boolean      rsult;
  2586.   Nlm_BaR        sb;
  2587.  
  2588.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE)fPanel);
  2589.   if (sb) {
  2590.     off = Nlm_GetValue (sb);
  2591.     item = GetItemNum ( off);
  2592.     line = off - GetLineStart(item);
  2593.     rsult = TRUE;
  2594.       }
  2595.   else {
  2596.       off = 0;
  2597.       item = 0;
  2598.       line = 0;  
  2599.       rsult = FALSE;
  2600.       }
  2601.   offset = off;
  2602.   firstShown = item + 1;
  2603.   firstLine = line;
  2604.   return rsult;
  2605. }
  2606.  
  2607.  
  2608.  
  2609.  
  2610.  
  2611.  
  2612. void  DRichView::Update( short from, short to) 
  2613. {
  2614.             // Invalidates and updates items in a document
  2615.   short         bottom,item,start,stop,swap,top, f1;
  2616.   DParagraph*  itemPtr;
  2617.   Nlm_RecT     r;
  2618.   Nlm_WindoW   tempPort;
  2619.  
  2620.   if (from >= 0 && to >= 0) {
  2621.     if (from == 0 || from > fNumItems) {
  2622.       start = 0;
  2623.       from = 0;
  2624.         } 
  2625.     else  
  2626.       start = from - 1;
  2627.      
  2628.     if (to == 0 || to > fNumItems) 
  2629.       stop = to = fNumItems;
  2630.     else  
  2631.       stop = to;
  2632.     
  2633.     for (item = start; item < stop; item++) {
  2634.       itemPtr = GetParaPtr(item);
  2635.       if (itemPtr) {
  2636.         itemPtr->fText = (char*) MemFree (itemPtr->fText);
  2637.         itemPtr->notCached = TRUE;
  2638.         itemPtr->neverCached = TRUE;
  2639.           }
  2640.         }
  2641.     if (Nlm_Enabled(fPanel) && Nlm_AllParentsEnabled(fPanel) &&
  2642.         Nlm_Visible(fPanel) && Nlm_AllParentsVisible(fPanel)) {
  2643.       tempPort = Nlm_SavePort(fPanel);
  2644.             ViewRect( r);
  2645.       Nlm_Select(fPanel);
  2646.       if (from > to && from != 0 && to != fNumItems) {
  2647.         swap = from;
  2648.         from = to;
  2649.         to = swap;
  2650.           }
  2651.       if (from > 0 && from <= fNumItems && IsVisible( from, top, bottom, f1))  
  2652.         r.top = top;
  2653.       if (to > 0 && to < fNumItems && IsVisible( to, top, bottom, f1))  
  2654.         r.bottom = bottom;
  2655.       Nlm_InsetRect(&r, -1, -1);
  2656.       Nlm_InvalRect(&r);
  2657.       if (tempPort) Nlm_RestorePort(tempPort);
  2658.         }
  2659.     AdjustScroll();
  2660.       }
  2661. }
  2662.  
  2663.  
  2664.  
  2665. void DRichView::SaveTableItem(DParagraph* itemPtr, FILE *f, Boolean tabStops)
  2666. {
  2667.                 //    Reformats and saves an item to a file
  2668.   char         ch;
  2669.   short     i;
  2670.   short     next,num,pos,row;
  2671.   char    *     ptr;
  2672.   char    *        text;
  2673.  
  2674.   next= 0;
  2675.   if (itemPtr && f) {
  2676.     text = itemPtr->fText;
  2677.     if (text && *text != '\0') {
  2678.       pos = 0;
  2679.       row = 0;
  2680.       ptr = text;
  2681.       ch = *ptr;
  2682.       while (ch != '\0') {
  2683.         if (ch == '\n') {
  2684.           row++;
  2685.           ptr++;
  2686.           pos = 0;
  2687.           fputc ('\n', f);
  2688.             } 
  2689.         else  {
  2690.           num = 0;
  2691.           while (ch != '\0' && ch != '\n') {
  2692.             num++;
  2693.             ch = ptr [num];
  2694.               }
  2695.           if (num > 0) {
  2696.             while (num > 0 && *ptr == '\t') {
  2697.               num--;
  2698.               ptr++;
  2699.               next += fTabCount;
  2700.                 }
  2701.             while (pos < next) {
  2702.               fputc (' ', f);
  2703.               pos++;
  2704.                 }
  2705.             for (i = 0; i < num; i++) {
  2706.               fputc (ptr [i], f);
  2707.               pos++;
  2708.                 }
  2709.               }
  2710.           ptr += num;
  2711.             }
  2712.         ch = *ptr;
  2713.       }
  2714.     }
  2715.   }
  2716. }
  2717.  
  2718.  
  2719.  
  2720.  
  2721. void DRichView::Save(DFile* f) 
  2722. { 
  2723.   if ( f ) {
  2724.     Boolean savevirt= fIsVirtual;
  2725.     fIsVirtual = FALSE;
  2726.     for (short i = 0; i < fNumItems; i++) {
  2727.       DParagraph* itemPtr = GetParaPtr( i);
  2728.       if (itemPtr) {
  2729.                 DParagraph itemData( itemPtr->fDataPtr, false, itemPtr->numRows, itemPtr, 
  2730.                                         itemPtr->fStyleIndex, itemPtr->fNumStyles, false);
  2731.            FormatText(0, &itemData, FALSE);
  2732.                 if (i > 0 && itemData.openSpace > 0) fputc ('\n', f->fFile);
  2733.            SaveTableItem(&itemData, f->fFile,  TRUE);
  2734.         }
  2735.       }
  2736.         fIsVirtual= savevirt;
  2737.     }
  2738. }
  2739.  
  2740.  
  2741.  
  2742.  
  2743.  
  2744. void DRichView::Print()    
  2745. { 
  2746. #if (defined(WIN_MAC) || defined (WIN_MSWIN))
  2747.   Boolean   goOn;
  2748.   short      i, item, line,pixels, visBelow;
  2749.   DParagraph*   itemPtr;
  2750.   Boolean   newPage;
  2751.   Nlm_RecT      r, rct;
  2752.   FloatHi           scale;
  2753.   Nlm_WindoW    w;
  2754.  
  2755.   Boolean savevirt= fIsVirtual;
  2756.   fIsVirtual = FALSE;
  2757.     if (fNumItems > 0) {
  2758.         ViewRect( rct);
  2759.     w = Nlm_StartPrinting ();
  2760.     if (w != NULL) {
  2761.       for (i = 0; i < MAXFONTS; i++) {
  2762.         gFontHeights[i].font = NULL;
  2763.         gFontHeights[i].height = 0;
  2764.           }
  2765.       goOn = TRUE;
  2766.       pixels = 0;
  2767.       item = 0;
  2768.       newPage = TRUE;
  2769.       while (item < fNumItems && goOn) {
  2770.         if (newPage) {
  2771.           goOn = Nlm_StartPage ();
  2772.           newPage = FALSE;
  2773.           Nlm_PrintingRect (&r);
  2774.             }
  2775.         if (goOn) {
  2776.           itemPtr = GetParaPtr( item);
  2777.           if (itemPtr) {
  2778.                         DParagraph itemData( itemPtr->fDataPtr, false, itemPtr->numRows, itemPtr, 
  2779.                                                                 itemPtr->fStyleIndex, itemPtr->fNumStyles, false);
  2780.             UpdateItemHeights (&itemData);
  2781.             scale = (FloatHi) (r.right - r.left) / (FloatHi) (rct.right - rct.left);
  2782.                    FormatText(0, &itemData, TRUE);
  2783.  
  2784.             if (pixels != 0)  r.top += itemData.leadHeight;
  2785.                 r.top += itemData.spaceBefore;
  2786.              
  2787.             visBelow = (r.bottom - r.top) / itemData.lineHeight;
  2788.             if ((itemData.keepTogether && visBelow < itemData.numRows) ||
  2789.                 itemData.newPage) {
  2790.               goOn = Nlm_EndPage ();
  2791.               if (goOn)  goOn = Nlm_StartPage ();
  2792.               newPage = FALSE;
  2793.               Nlm_PrintingRect (&r);
  2794.               visBelow = (r.bottom - r.top) / itemData.lineHeight;
  2795.                 }
  2796.             line = 0;
  2797.             while (visBelow + line < itemData.numRows && goOn) {
  2798.                   pixels = DrawStyledItem( &itemData, &r, item+1, line, TRUE, NULL);
  2799.               r.top += pixels;
  2800.                     r.top += itemData.spaceAfter;
  2801.               line += visBelow;
  2802.               goOn = Nlm_EndPage ();
  2803.               if (goOn) Nlm_StartPage ();
  2804.               newPage = FALSE;
  2805.               Nlm_PrintingRect (&r);
  2806.               visBelow = (r.bottom - r.top) / itemData.lineHeight;
  2807.                 }
  2808.             if (visBelow > 0 && goOn) {
  2809.                   pixels = DrawStyledItem( &itemData, &r, item+1, line, TRUE, NULL);
  2810.               r.top += pixels;
  2811.                     r.top += itemData.spaceAfter;
  2812.                 }
  2813.                
  2814.               }
  2815.             }
  2816.         item++;
  2817.         if (r.top >= r.bottom) {
  2818.           goOn = Nlm_EndPage ();
  2819.           newPage = TRUE;
  2820.             }
  2821.           }
  2822.       if ((!newPage) && goOn) 
  2823.         goOn = Nlm_EndPage ();
  2824.        
  2825.       Nlm_EndPrinting (w);
  2826.       for (i = 0; i < MAXFONTS; i++) {
  2827.         gFontHeights [i].font = NULL;
  2828.         gFontHeights [i].height = 0;
  2829.         }
  2830.         }
  2831.         }
  2832.     fIsVirtual= savevirt;
  2833.    
  2834. #else
  2835.     Nlm_Message(MSG_OK,"Printing is not yet defined for this window system");
  2836. #endif
  2837. }
  2838.  
  2839.  
  2840.  
  2841. void  DRichView::SetTabs( short theTabstops) 
  2842. { 
  2843.     fTabCount= theTabstops;
  2844. }
  2845.  
  2846.  
  2847. #if 0
  2848. enum docFormats {
  2849.     kUnknownformat,
  2850.     kTextformat,
  2851.     kRTFformat,
  2852.     kPICTformat,
  2853.     kHTMLformat,
  2854.     kMaxDocformat
  2855.     };
  2856. #endif
  2857.  
  2858. void  DRichView::ShowFile( char* filename, Nlm_FonT font) 
  2859. {
  2860.     fDocFormat= DRichHandler::kUnknownformat;
  2861.     DRTFHandler rtfhandler( this, NULL);
  2862.     if ( rtfhandler.ProcessFile( filename) ) 
  2863.         fDocFormat= rtfhandler.Format();
  2864.     else {
  2865.         DPICTHandler picthandler( this, NULL);
  2866.         if ( picthandler.ProcessFile( filename) )
  2867.             fDocFormat= picthandler.Format();
  2868.         else  { 
  2869.           DGIFHandler gifhandler( this, NULL);
  2870.           if ( gifhandler.ProcessFile( filename) ) 
  2871.               fDocFormat= gifhandler.Format(); 
  2872.           else {
  2873.               DHTMLHandler htmlhandler( this, NULL);
  2874.               if ( htmlhandler.ProcessFile( filename) ) 
  2875.                   fDocFormat= htmlhandler.Format(); 
  2876.               else {
  2877. #if 1
  2878.                   DRichHandler texthandler( this, NULL);
  2879.                   if ( texthandler.ProcessFile( filename) ) 
  2880.                       fDocFormat= texthandler.Format(); 
  2881. #else
  2882.                 ShowTextFile( filename, font);
  2883.                   fDocFormat= DRichHandler::kTextformat; 
  2884. #endif
  2885.                   }
  2886.               }
  2887.           }
  2888.         }
  2889. }
  2890.  
  2891. void  DRichView::ShowDoc( char* doctext, ulong doclength) 
  2892. {
  2893.     if (!doctext) return;
  2894.     if (!doclength) doclength= StrLen( doctext);
  2895.     char*    docend= doctext + doclength;
  2896.     
  2897.     if (fDocFormat) switch (fDocFormat) {
  2898.     
  2899.         case DRichHandler::kTextformat: {
  2900.             DRichHandler texthandler( this, NULL);
  2901.             if ( texthandler.ProcessData( doctext, docend, true, doclength) ) return;
  2902.             }
  2903.             break;
  2904.  
  2905.         case DPICTHandler::kPICTformat: {
  2906.             DPICTHandler picthandler( this, NULL);
  2907.             if ( picthandler.ProcessData( doctext, docend, true, doclength) ) return;
  2908.             }
  2909.             break;
  2910.             
  2911.         case DGIFHandler::kGIFformat: {
  2912.           DGIFHandler gifhandler( this, NULL);
  2913.             if ( gifhandler.ProcessData( doctext, docend, true, doclength) ) return;
  2914.             }
  2915.             break;
  2916.  
  2917.         case DHTMLHandler::kHTMLformat: {
  2918.             DHTMLHandler htmlhandler( this, NULL);
  2919.             if ( htmlhandler.ProcessData( doctext, docend, true, doclength) ) return;
  2920.             }
  2921.             break;
  2922.  
  2923.         case DRTFHandler::kRTFformat: { 
  2924.             DRTFHandler rtfhandler( this, NULL);
  2925.             if ( rtfhandler.ProcessData( doctext, docend, true, doclength) ) return;
  2926.             }
  2927.             break;
  2928.         }
  2929.         
  2930.     fDocFormat= DRichHandler::kUnknownformat;
  2931.     
  2932.     DRTFHandler rtfhandler( this, NULL);
  2933.     if ( rtfhandler.ProcessData( doctext, docend, true, doclength) ) 
  2934.         fDocFormat= rtfhandler.Format();
  2935.     else {
  2936.         DPICTHandler picthandler( this, NULL);
  2937.         if ( picthandler.ProcessData( doctext, docend, true, doclength) )
  2938.             fDocFormat= picthandler.Format();
  2939.         else  { 
  2940.           DGIFHandler gifhandler( this, NULL);
  2941.           if ( gifhandler.ProcessData( doctext, docend, true, doclength) ) 
  2942.               fDocFormat= gifhandler.Format(); 
  2943.           else {
  2944.               DHTMLHandler htmlhandler( this, NULL);
  2945.               if ( htmlhandler.ProcessData( doctext, docend, true, doclength) ) 
  2946.                   fDocFormat= htmlhandler.Format(); 
  2947.               else {
  2948.                   DRichHandler texthandler( this, NULL);
  2949.                   if ( texthandler.ProcessData( doctext, docend, true, doclength) ) 
  2950.                       fDocFormat= texthandler.Format(); 
  2951.                   }
  2952.               }
  2953.           }
  2954.         }
  2955. }
  2956.  
  2957.  
  2958.  
  2959. void DRichView::ShowTextFile( char* filename, Nlm_FonT font)
  2960. {    
  2961.     DParagraph    para;
  2962.     DRichStyle    aStyle;
  2963.     if (font) aStyle.font= font;
  2964.     aStyle.last= true;
  2965.   ShowFileFancy( filename, ¶, &aStyle, 1);
  2966. }
  2967.  
  2968.  
  2969.  
  2970.  
  2971.  
  2972. void  DRichView::ShowFileFancy( char* filename, DParagraph* parFormat,  
  2973.                                                                 DRichStyle* styles, short nstyles, short tabStops) 
  2974. {
  2975.   char         ch;
  2976.   short       actual, cnt, leftOver;
  2977.   long         cntr;
  2978.   FILE         *fp;
  2979.   Nlm_RecT     r;
  2980.   Nlm_WindoW   tempPort;
  2981.   char      * text,  * txt;
  2982.   Nlm_FonT         font;
  2983. #ifdef COMP_MPW
  2984.   char*  p;
  2985. #endif
  2986. #if (defined(OS_DOS) || defined (OS_NT))
  2987.   char*  p;
  2988.   char*  q;
  2989. #endif
  2990.     DParagraph    para;
  2991.  
  2992.   if ( filename  && filename [0] != '\0') {
  2993.          fTabCount = tabStops;
  2994.     if (parFormat == NULL) parFormat = ¶
  2995.     Nlm_Reset (fPanel);
  2996.     tempPort = Nlm_SavePort (fPanel);
  2997.         ViewRect( r);
  2998.     if (styles) font= styles->font;
  2999.     if (font == NULL) font = Nlm_programFont; //Nlm_systemFont;
  3000.      
  3001.     text = (char*) MemNew (16000);
  3002.     if (text) {
  3003.       fp = FileOpen (filename, "r");
  3004.       if (fp) {
  3005.         leftOver = 0;
  3006.         cntr = FileLength (filename);
  3007.         cnt = (short) MIN (cntr, 15000L);
  3008.  
  3009.         while (cnt > 0 && cntr > 0) {
  3010.           txt = text + leftOver;
  3011.           actual = (short) FileRead (txt, 1, cnt, fp);
  3012.           if (actual > 0) {
  3013.             cnt = actual;
  3014.             txt [cnt] = '\0';
  3015.             ch = fgetc (fp);
  3016.             while (ch != '\0' && ch != '\n' && cnt < 15900) {
  3017.               txt [cnt] = ch;
  3018.               cnt++;
  3019.               ch = fgetc (fp);
  3020.                 }
  3021.             while ((ch == '\n' || ch == '\r') && cnt < 15900) {
  3022.               txt [cnt] = ch;
  3023.               cnt++;
  3024.               ch = fgetc (fp);
  3025.                 }
  3026.             txt [cnt] = '\0';
  3027. #if (defined(OS_DOS) || defined (OS_NT))
  3028.             p = text;
  3029.             q = text;
  3030.             while (*p) {
  3031.               if (*p == '\r') {
  3032.                 p++;
  3033.               } else {
  3034.                 *q = *p;
  3035.                 p++;
  3036.                 q++;
  3037.               }
  3038.             }
  3039.             *q = '\0';
  3040. #endif
  3041. #ifdef COMP_MPW
  3042.             p = text;
  3043.             while (*p) {
  3044.               if (*p == '\r') {
  3045.                 *p = '\n';
  3046.               }
  3047.               p++;
  3048.             }
  3049. #endif
  3050.             Append( text, parFormat, styles, nstyles, NULL); 
  3051.                 /* dgg -- need to fiddle w/ styles to match to subset of text !! */
  3052.             leftOver = 1;
  3053.             text [0] = ch;
  3054.             cntr -= cnt;
  3055.             cnt = (short) MIN (cntr, 15000L);
  3056.               } 
  3057.           else {
  3058.             cnt = 0;
  3059.             cntr = 0;
  3060.               }
  3061.             }
  3062.         FileClose (fp);
  3063.           }
  3064.       text = (char*) MemFree (text);
  3065.         }
  3066.     if (!fAutoAdjust) AdjustScroll();
  3067.     if (tempPort) Nlm_RestorePort (tempPort);
  3068.       }
  3069. }
  3070.  
  3071.  
  3072.  
  3073.         
  3074.     
  3075.     
  3076. void DRichView::DoubleClick(Nlm_PoinT mouse)
  3077. {
  3078.     short                 item, row, atch;
  3079.     Nlm_RecT        rct;
  3080.     char                wordAt[512];
  3081.     DRichStyle     * styleAt = NULL;
  3082.  
  3083.         // sickly demo
  3084.     wordAt[0]= 0;
  3085.     MapPoint( mouse, item, row, &rct, wordAt, 512, NULL/*styleAt*/);
  3086.     atch= gMapOfs;  
  3087.     SetSelectedText( item, atch, item, atch); 
  3088.     if (fMapStyle) {
  3089.         if (fMapStyle->ispict) {
  3090.             Nlm_PoinT atp;
  3091.             atp.x= mouse.x - fDrawr.left;
  3092.             atp.y= mouse.y - fDrawr.top;
  3093.             // if fMapStyle->ismap, do things w/ gopher link
  3094. #if 0
  3095.             Message(MSG_OK, "dblClik in picture x=%d y=%d, picwd=%d picht=%d", 
  3096.                     atp.x, atp.y, fMapStyle->pixwidth, fMapStyle->pixheight);
  3097. #endif
  3098.             }
  3099.         else {
  3100.             Nlm_InvertRect(&rct);
  3101. #if 0
  3102.             Message(MSG_OK, "dblClik text at prg=%d row=%d sto=%d '%s'",
  3103.                              item, row, fMapStyle->nextofs, wordAt);
  3104. #endif
  3105.             InvalRect( rct);
  3106.             }
  3107.         }
  3108.     //this->Select();
  3109.     this->GetWindow()->Select();
  3110. }
  3111.  
  3112. void DRichView::SingleClick(Nlm_PoinT mouse) 
  3113. {
  3114.     short             item, row, atch;
  3115.     Nlm_RecT        rct;
  3116.     char                wordAt[512];
  3117.  
  3118.     wordAt[0]= 0;
  3119.     MapPoint( mouse, item, row, &rct, wordAt, 512, NULL/*styleAt*/);
  3120.     atch= gMapOfs;  
  3121.         SetSelectedText( item, atch, item, atch); 
  3122. }
  3123.  
  3124. void DRichView::Click(Nlm_PoinT mouse)
  3125. {
  3126.     ClearCurrentStyle(); // Vibrant click calls change FONT !!
  3127.     if (Nlm_dblClick) DoubleClick( mouse);
  3128.     else SingleClick(mouse);        
  3129. }
  3130.     
  3131. void  DRichView::SetAutoAdjust( Boolean autoAdjust) 
  3132. {
  3133.     fAutoAdjust= autoAdjust;
  3134. }
  3135.  
  3136.  
  3137. #if 0
  3138. void DRichView::Show()
  3139. {
  3140.   Nlm_Update(); //!? need since took out vibwnds autoupdate for RestorePort
  3141. }
  3142. #endif
  3143.  
  3144. // this is DPanel form:
  3145. //void DRichView::Scroll( Boolean vertical, DView* scrollee, short newval, short oldval)
  3146.  
  3147. void DRichView::ScrollDoc(Nlm_BaR sb, short newval, short oldval)
  3148. {
  3149.         // Scroll bar callback that takes suppressed partial lines into account
  3150.         // this is good only for vertical==true
  3151.   Boolean      goToEnd;
  3152.   short     barmax, barval, firstShown;
  3153.   short     height,highest,highFree,item, lo1, hi1;
  3154.   short     line, lineInto,lowest,lowFree;
  3155.   short     pixels,pgDn,pgUp,vis;
  3156.   Nlm_RecT     r;
  3157.   DParagraph*  itemPtr;
  3158.     
  3159.     // Nlm_SlatE s= (Nlm_SlatE) fPanel;
  3160.     
  3161.   if (oldval != newval) {
  3162.     if (Nlm_Visible (fPanel) && Nlm_AllParentsVisible (fPanel)) {
  3163.             ViewRect( r);
  3164.       height = r.bottom - r.top;
  3165.       item = GetItemNum ( newval);
  3166.       line = newval - GetLineStart( item);
  3167.       firstShown = item;
  3168.       lineInto = line;
  3169.       lowest = INT2_MAX;
  3170.       highest = INT2_MIN;
  3171.       pgUp = VisLinesAbove ( &r, item, line, lowest, highest) - 1;
  3172.       pgDn = VisLinesBelow ( &r, item, line, lowest, highest) - 1;
  3173.       if (pgDn < 1)  pgDn = 1;
  3174.       if (pgUp < 1)  pgUp = 1;
  3175.       if (lowest < INT2_MAX)  
  3176.         fNumLines = UpdateLineStarts ( lowest);
  3177.       Nlm_Select (fPanel);
  3178.       if ((newval > oldval && newval - pgUp <= oldval) ||
  3179.           (newval < oldval && newval + pgDn >= oldval)) {
  3180.         pixels = PixelsBetween ( &r, newval, oldval, lo1, hi1);
  3181.         if (ABS (pixels) < height) {
  3182.           Nlm_ScrollRect (&r, 0, pixels);
  3183.           if (pixels<0) r.top = r.bottom + pixels; // - 5;
  3184.           else r.bottom = r.top + pixels; // + 5;
  3185.           Nlm_InsetRect (&r, -1, -1);
  3186.           Nlm_InvalRect (&r);
  3187.             } 
  3188.         else {
  3189.           Nlm_InsetRect (&r, -1, -1);
  3190.           Nlm_InvalRect (&r);
  3191.             }
  3192.           } 
  3193.       else {
  3194.         Nlm_InsetRect (&r, -1, -1);
  3195.         Nlm_InvalRect (&r);
  3196.           }
  3197.       lowFree = INT2_MAX;
  3198.       highFree = INT2_MIN;
  3199.       for (item = 0; item < lowest; item++)  
  3200.         FreeCachedItem ( item, lowFree, highFree);
  3201.       for (item = highest + 1; item < fNumItems; item++) 
  3202.         FreeCachedItem ( item, lowFree, highFree);
  3203.       if (lowFree < INT2_MAX) 
  3204.         fNumLines = UpdateLineStarts ( lowFree);
  3205.       
  3206.       barmax = 0;
  3207.       goToEnd = (Boolean) (newval == fBarmax);
  3208.       if (fNumLines > 0 && fNumItems > 0) {
  3209.         itemPtr = GetParaPtr( fNumItems - 1);
  3210.         if (itemPtr) {
  3211.                     ViewRect( r);
  3212.           lowest = INT2_MAX;
  3213.           highest = INT2_MIN;
  3214.           vis = VisLinesAbove ( &r, fNumItems - 1,
  3215.                                itemPtr->numRows - 1, lowest, highest);
  3216.           if (lowest < INT2_MAX)  
  3217.             fNumLines = UpdateLineStarts ( lowest);
  3218.           barmax = fNumLines - vis;
  3219.             }
  3220.           }
  3221.       barval = GetLineStart( firstShown) + lineInto;
  3222.       if (goToEnd) barval = barmax;
  3223.     
  3224.       if (barval > fBarmax) {
  3225.         Nlm_CorrectBarMax (sb, barmax);
  3226.         Nlm_CorrectBarValue (sb, barval);
  3227.           } 
  3228.       else {
  3229.         Nlm_CorrectBarValue (sb, barval);
  3230.         Nlm_CorrectBarMax (sb, barmax);
  3231.           }
  3232.       Nlm_CorrectBarPage (sb, pgUp, pgDn);
  3233.       fBarmax = barmax;
  3234.       Nlm_Update ();
  3235.     }
  3236.   }
  3237. }
  3238.  
  3239.  
  3240.  
  3241. // Performs garbage collection on document data
  3242.  
  3243. void DRichView::ResetDoc()
  3244. {
  3245.     DeleteAll();
  3246.   fNumItems = 0;
  3247.   fNumLines = 0;
  3248.   fBarmax = 0;
  3249.   //DRichView::InitRichView();
  3250. }
  3251.  
  3252.  
  3253.  
  3254.  
  3255.  
  3256.  
  3257.  
  3258.  
  3259.  
  3260. // class DRichFindDialog
  3261.  
  3262. class DRichFindDialog : public DFindDialog {
  3263. public:
  3264.     DRichView* fView;
  3265.     char    * fLastTarget;
  3266.     short        fLastParag, fLastChar;
  3267.     DRichFindDialog(  DRichView* itsView);
  3268.     virtual void DoFind();
  3269.     virtual void BuildDlog();
  3270. };
  3271.  
  3272. DRichFindDialog::DRichFindDialog(  DRichView* itsView) :
  3273.         fView( itsView), fLastTarget(NULL),  fLastParag(-1), fLastChar(-1)
  3274. {
  3275. }
  3276.  
  3277.  
  3278. void DRichFindDialog::BuildDlog()
  3279. {
  3280.     DFindDialog::BuildDlog();
  3281.  
  3282.     DView* av;
  3283.     av= FindSubview(replaceId); if (av) { av->Disable(); } //av->Hide();
  3284.     av= FindSubview(replaceFindId); if (av) { av->Disable();  }
  3285.     av= FindSubview(replaceAllId); if (av) { av->Disable(); }
  3286.     av= FindSubview(cBackwards);     if (av) { av->Disable(); }
  3287.     av= FindSubview(cFullWord); if (av) { av->Disable(); }
  3288.     //av= FindSubview(cCaseSense); if (av) { av->Disable(); }
  3289.     if (fReplaceText) fReplaceText->Disable();
  3290. }
  3291.  
  3292. void DRichFindDialog::DoFind() 
  3293. {
  3294.     const char    *target;
  3295.     Boolean     casesense, back, fullword, found;
  3296.     short            paragat, charat;
  3297.     long            len;
  3298.     
  3299.     target= this->GetFind();
  3300.     if (target && *target) {
  3301.         casesense    = this->CaseSensitive();
  3302.         back= this->Backwards();         // not yet supported
  3303.         fullword= this->FullWord(); // not yet supported
  3304.         paragat= fView->fSelParag - 1; // offset by -1 for real parag# -- MESS !
  3305.         charat= fView->fSelChar;
  3306.         len= StrLen(target);
  3307.         if (fLastTarget && StringCmp(target, fLastTarget)==0 
  3308.          && paragat == fLastParag && charat == fLastChar) {
  3309.             charat += len;
  3310.             found= fView->Find( (char*)target, paragat, charat, paragat, charat, casesense); 
  3311.             }
  3312.         else {
  3313.             if (fLastTarget) MemFree(fLastTarget);
  3314.             fLastTarget= StrDup(target);
  3315.             found= fView->Find( (char*)target, paragat, charat, paragat, charat, casesense); 
  3316.             }
  3317.         fLastParag= paragat;
  3318.         fLastChar = charat;
  3319.         if (found) {
  3320.             fView->SetSelectedText( paragat+1, charat, paragat+1, charat + len);
  3321.             }
  3322.         }
  3323. }                
  3324.  
  3325.  
  3326.  
  3327. //class    DRichTextDoc : public DWindow
  3328.  
  3329.  
  3330.  
  3331. Nlm_RecT DRichTextDoc::gRichDocRect = { 0, 0, 0, 0 };
  3332.  
  3333.  
  3334. DRichTextDoc::DRichTextDoc( long id, Boolean makeRichView, Nlm_FonT itsFont) :
  3335.         DWindow( id, gApplication, document),
  3336.         fRichView(NULL), fFloatingEditText(NULL)
  3337. {     
  3338.     Nlm_PoinT nps;
  3339.     fFont= itsFont;
  3340.     this->GetNextPosition( &nps);
  3341.     fFloatingEditText= (DDialogText*) new DHiddenText(0,this,"");
  3342.     this->SetNextPosition( nps);
  3343.     fFloatingEditText->Hide();
  3344.     //this->SetEditText(fFloatingEditText);
  3345.     
  3346.     if (makeRichView) {
  3347.         this->GetNextPosition( &nps);
  3348.         nps.x= 0; // fix for odd offset
  3349.         this->SetNextPosition( nps);
  3350.         fRichView= new DRichView( 0, this, gPrintManager->PageWidth(), 0);
  3351.         fRichView->SetSlateBorder( true);
  3352.         fRichView->SetResize( DView::matchsuper, DView::relsuper);
  3353.         //fRichView->SetTabs( gTextTabStops);
  3354.         //fRichView->SizeToSuperview( fWindow, true, false); // this needs to adjust for if view has scrollbar !
  3355.         //fSaveHandler= fRichView; //DRichView() installs these handlers !
  3356.         //fPrintHandler= fRichView;
  3357.         }
  3358. }
  3359.  
  3360.                               
  3361. void DRichTextDoc::Open()
  3362. {
  3363.     this->CalcWindowSize();
  3364.     if (!fFindDlog) fFindDlog= new DRichFindDialog( fRichView);
  3365.     fRichView->SizeToSuperview( this, true, false); // this needs to adjust for if view has scrollbar !
  3366.     DWindow::Open();
  3367. }
  3368.  
  3369. void DRichTextDoc::OpenText( char* doctext, ulong doclength)
  3370. {
  3371.     if (doctext) {
  3372.         fRichView->ShowDoc( doctext, doclength);
  3373.         Open();
  3374.         }
  3375. }
  3376.  
  3377.  
  3378. void DRichTextDoc::Open( DFile* aFile)
  3379. {
  3380.     if (aFile) {
  3381.         SetTitle( (char*)aFile->GetShortname());
  3382.         SetFilename( (char*)aFile->GetName());
  3383.         fRichView->ShowFile( (char*)aFile->GetName(), fFont);
  3384.         }
  3385.     Open();
  3386. }
  3387.  
  3388. void  DRichTextDoc::Open( char* filename) 
  3389. {
  3390.     SetTitle( (char*)DFileManager::FilenameFromPath(filename));
  3391.     SetFilename( (char*) filename);
  3392.     fRichView->ShowFile( filename, fFont);
  3393.   Open();
  3394. }
  3395.  
  3396. void DRichTextDoc::Close()
  3397. {
  3398.     //if (!Nlm_EmptyRect(&fViewrect)) gRichDocRect= fViewrect;  
  3399.     if (fRichView) fRichView->ViewRect( gRichDocRect);  // GetPosition
  3400.     DWindow::Close();
  3401. }
  3402.  
  3403. void DRichTextDoc::ResizeWin()
  3404. {
  3405.     DWindow::ResizeWin();
  3406.     if (fRichView) fRichView->ViewRect( gRichDocRect);
  3407.     //if (!Nlm_EmptyRect(&fViewrect)) gRichDocRect= fViewrect;  
  3408. }
  3409.  
  3410. Boolean DRichTextDoc::IsMyAction(DTaskMaster* action) 
  3411. {
  3412.     switch(action->Id()) {
  3413.         case DApplication::kUndo:
  3414.             Message(MSG_OK,"DRichTextDoc::Undo not ready.");
  3415.             return true;
  3416.         case DApplication::kCut:
  3417.             Message(MSG_OK,"DRichTextDoc::Cut not ready.");
  3418.             //this->CutText(); 
  3419.             return true;
  3420.             
  3421.         case DApplication::kCopy: {
  3422.             char* theText= NULL;
  3423.             if (fRichView) theText= fRichView->GetSelectedText();
  3424.             if (theText) {
  3425.                 fFloatingEditText->SetText(theText);
  3426.                 fFloatingEditText->SetSelection(0,32000); 
  3427.           fFloatingEditText->CopyText(); 
  3428.           MemFree( theText);
  3429.                 fFloatingEditText->SetText(""); // don't need to keep extra copies around
  3430.                 //Message(MSG_OK,"DRichTextDoc::Copied text selection.");
  3431.           }
  3432.         }
  3433.             return true;
  3434.             
  3435.         case DApplication::kPaste:
  3436.             Message(MSG_OK,"DRichTextDoc::Paste not ready.");
  3437.             //this->PasteText(); 
  3438.             return true;
  3439.         case DApplication::kClear:
  3440.             Message(MSG_OK,"DRichTextDoc::Clear not ready.");
  3441.             //this->ClearText(); 
  3442.             return true;
  3443.         case DApplication::kSelectAll:
  3444.             //Message(MSG_OK,"DRichTextDoc::Select all not ready.");
  3445.             if (fRichView) fRichView->SelectAll();
  3446.             //this->SetSelection(0,0,32000,32000); 
  3447.             return true;
  3448.         default:
  3449.             return DWindow::IsMyAction(action);
  3450.         }
  3451. }
  3452.  
  3453.  
  3454. // class DRichApplication : public DApplication
  3455.  
  3456.  
  3457. DRichApplication::DRichApplication()
  3458. {
  3459.     //fAcceptableFileTypes= "TEXTPICTGIFfRTF "; /* up to 4 types, or null for all types */
  3460.     // ^^ not working, only 1st seen !?
  3461.     //fAcceptableFileTypes= NULL;
  3462. }
  3463.  
  3464.  
  3465. void DRichApplication::OpenDocument(DFile* aFile)
  3466. {
  3467.     if (aFile && aFile->Exists()) {
  3468.         gCursor->watch();
  3469.         DRichTextDoc* aDoc= new DRichTextDoc();
  3470.         aDoc->Open( aFile);
  3471.         gCursor->arrow();
  3472.         }
  3473. }
  3474.  
  3475.  
  3476.